package com.sunny.fetch.pojo;

import javax.persistence.*;

@Table(name = "f_fina_indicator")
public class FFinaIndicator {
    @Id
    private Long tid;

    /**
     * TS代码
     */
    @Column(name = "ts_code")
    private String tsCode;

    /**
     * 公告日期
     */
    @Column(name = "ann_date")
    private String annDate;

    /**
     * 报告期
     */
    @Column(name = "end_date")
    private String endDate;

    /**
     * 基本每股收益
     */
    private Float eps;

    /**
     * 稀释每股收益
     */
    @Column(name = "dt_eps")
    private Float dtEps;

    /**
     * 每股营业总收入
     */
    @Column(name = "total_revenue_ps")
    private Float totalRevenuePs;

    /**
     * 每股营业收入
     */
    @Column(name = "revenue_ps")
    private Float revenuePs;

    /**
     * 每股资本公积
     */
    @Column(name = "capital_rese_ps")
    private Float capitalResePs;

    /**
     * 每股盈余公积
     */
    @Column(name = "surplus_rese_ps")
    private Float surplusResePs;

    /**
     * 每股未分配利润
     */
    @Column(name = "undist_profit_ps")
    private Float undistProfitPs;

    /**
     * 非经常性损益
     */
    @Column(name = "extra_item")
    private Float extraItem;

    /**
     * 扣除非经常性损益后的净利润
     */
    @Column(name = "profit_dedt")
    private Float profitDedt;

    /**
     * 毛利
     */
    @Column(name = "gross_margin")
    private Float grossMargin;

    /**
     * 流动比率
     */
    @Column(name = "current_ratio")
    private Float currentRatio;

    /**
     * 速动比率
     */
    @Column(name = "quick_ratio")
    private Float quickRatio;

    /**
     * 保守速动比率
     */
    @Column(name = "cash_ratio")
    private Float cashRatio;

    /**
     * 存货周转天数
     */
    @Column(name = "invturn_days")
    private Float invturnDays;

    /**
     * 应收账款周转天数
     */
    @Column(name = "arturn_days")
    private Float arturnDays;

    /**
     * 存货周转率
     */
    @Column(name = "inv_turn")
    private Float invTurn;

    /**
     * 应收账款周转率
     */
    @Column(name = "ar_turn")
    private Float arTurn;

    /**
     * 流动资产周转率
     */
    @Column(name = "ca_turn")
    private Float caTurn;

    /**
     * 固定资产周转率
     */
    @Column(name = "fa_turn")
    private Float faTurn;

    /**
     * 总资产周转率
     */
    @Column(name = "assets_turn")
    private Float assetsTurn;

    /**
     * 经营活动净收益
     */
    @Column(name = "op_income")
    private Float opIncome;

    /**
     * 价值变动净收益
     */
    @Column(name = "valuechange_income")
    private Float valuechangeIncome;

    /**
     * 利息费用
     */
    @Column(name = "interst_income")
    private Float interstIncome;

    /**
     * 折旧与摊销
     */
    private Float daa;

    /**
     * 息税前利润
     */
    private Float ebit;

    /**
     * 息税折旧摊销前利润
     */
    private Float ebitda;

    /**
     * 企业自由现金流量
     */
    private Float fcff;

    /**
     * 股权自由现金流量
     */
    private Float fcfe;

    /**
     * 无息流动负债
     */
    @Column(name = "current_exint")
    private Float currentExint;

    /**
     * 无息非流动负债
     */
    @Column(name = "noncurrent_exint")
    private Float noncurrentExint;

    /**
     * 带息债务
     */
    private Float interestdebt;

    /**
     * 净债务
     */
    private Float netdebt;

    /**
     * 有形资产
     */
    @Column(name = "tangible_asset")
    private Float tangibleAsset;

    /**
     * 营运资金
     */
    @Column(name = "working_capital")
    private Float workingCapital;

    /**
     * 营运流动资本
     */
    @Column(name = "networking_capital")
    private Float networkingCapital;

    /**
     * 全部投入资本
     */
    @Column(name = "invest_capital")
    private Float investCapital;

    /**
     * 留存收益
     */
    @Column(name = "retained_earnings")
    private Float retainedEarnings;

    /**
     * 期末摊薄每股收益
     */
    @Column(name = "diluted2_eps")
    private Float diluted2Eps;

    /**
     * 每股净资产
     */
    private Float bps;

    /**
     * 每股经营活动产生的现金流量净额
     */
    private Float ocfps;

    /**
     * 每股留存收益
     */
    private Float retainedps;

    /**
     * 每股现金流量净额
     */
    private Float cfps;

    /**
     * 每股息税前利润
     */
    @Column(name = "ebit_ps")
    private Float ebitPs;

    /**
     * 每股企业自由现金流量
     */
    @Column(name = "fcff_ps")
    private Float fcffPs;

    /**
     * 每股股东自由现金流量
     */
    @Column(name = "fcfe_ps")
    private Float fcfePs;

    /**
     * 销售净利率
     */
    @Column(name = "netprofit_margin")
    private Float netprofitMargin;

    /**
     * 销售毛利率
     */
    @Column(name = "grossprofit_margin")
    private Float grossprofitMargin;

    /**
     * 销售成本率
     */
    @Column(name = "cogs_of_sales")
    private Float cogsOfSales;

    /**
     * 销售期间费用率
     */
    @Column(name = "expense_of_sales")
    private Float expenseOfSales;

    /**
     * 净利润/营业总收入
     */
    @Column(name = "profit_to_gr")
    private Float profitToGr;

    /**
     * 销售费用/营业总收入
     */
    @Column(name = "saleexp_to_gr")
    private Float saleexpToGr;

    /**
     * 管理费用/营业总收入
     */
    @Column(name = "adminexp_of_gr")
    private Float adminexpOfGr;

    /**
     * 财务费用/营业总收入
     */
    @Column(name = "finaexp_of_gr")
    private Float finaexpOfGr;

    /**
     * 资产减值损失/营业总收入
     */
    @Column(name = "impai_ttm")
    private Float impaiTtm;

    /**
     * 营业总成本/营业总收入
     */
    @Column(name = "gc_of_gr")
    private Float gcOfGr;

    /**
     * 营业利润/营业总收入
     */
    @Column(name = "op_of_gr")
    private Float opOfGr;

    /**
     * 息税前利润/营业总收入
     */
    @Column(name = "ebit_of_gr")
    private Float ebitOfGr;

    /**
     * 净资产收益率
     */
    private Float roe;

    /**
     * 加权平均净资产收益率
     */
    @Column(name = "roe_waa")
    private Float roeWaa;

    /**
     * 净资产收益率(扣除非经常损益)
     */
    @Column(name = "roe_dt")
    private Float roeDt;

    /**
     * 总资产报酬率
     */
    private Float roa;

    /**
     * 总资产净利润
     */
    private Float npta;

    /**
     * 投入资本回报率
     */
    private Float roic;

    /**
     * 年化净资产收益率
     */
    @Column(name = "roe_yearly")
    private Float roeYearly;

    /**
     * 年化总资产报酬率
     */
    @Column(name = "roa2_yearly")
    private Float roa2Yearly;

    /**
     * 平均净资产收益率(增发条件)
     */
    @Column(name = "roe_avg")
    private Float roeAvg;

    /**
     * 经营活动净收益/利润总额
     */
    @Column(name = "opincome_of_ebt")
    private Float opincomeOfEbt;

    /**
     * 价值变动净收益/利润总额
     */
    @Column(name = "investincome_of_ebt")
    private Float investincomeOfEbt;

    /**
     * 营业外收支净额/利润总额
     */
    @Column(name = "n_op_profit_of_ebt")
    private Float nOpProfitOfEbt;

    /**
     * 所得税/利润总额
     */
    @Column(name = "tax_to_ebt")
    private Float taxToEbt;

    /**
     * 扣除非经常损益后的净利润/净利润
     */
    @Column(name = "dtprofit_to_profit")
    private Float dtprofitToProfit;

    /**
     * 销售商品提供劳务收到的现金/营业收入
     */
    @Column(name = "salescash_to_or")
    private Float salescashToOr;

    /**
     * 经营活动产生的现金流量净额/营业收入
     */
    @Column(name = "ocf_to_or")
    private Float ocfToOr;

    /**
     * 经营活动产生的现金流量净额/经营活动净收益
     */
    @Column(name = "ocf_to_opincome")
    private Float ocfToOpincome;

    /**
     * 资本支出/折旧和摊销
     */
    @Column(name = "capitalized_to_da")
    private Float capitalizedToDa;

    /**
     * 资产负债率
     */
    @Column(name = "debt_to_assets")
    private Float debtToAssets;

    /**
     * 权益乘数
     */
    @Column(name = "assets_to_eqt")
    private Float assetsToEqt;

    /**
     * 权益乘数(杜邦分析)
     */
    @Column(name = "dp_assets_to_eqt")
    private Float dpAssetsToEqt;

    /**
     * 流动资产/总资产
     */
    @Column(name = "ca_to_assets")
    private Float caToAssets;

    /**
     * 非流动资产/总资产
     */
    @Column(name = "nca_to_assets")
    private Float ncaToAssets;

    /**
     * 有形资产/总资产
     */
    @Column(name = "tbassets_to_totalassets")
    private Float tbassetsToTotalassets;

    /**
     * 带息债务/全部投入资本
     */
    @Column(name = "int_to_talcap")
    private Float intToTalcap;

    /**
     * 归属于母公司的股东权益/全部投入资本
     */
    @Column(name = "eqt_to_talcapital")
    private Float eqtToTalcapital;

    /**
     * 流动负债/负债合计
     */
    @Column(name = "currentdebt_to_debt")
    private Float currentdebtToDebt;

    /**
     * 非流动负债/负债合计
     */
    @Column(name = "longdeb_to_debt")
    private Float longdebToDebt;

    /**
     * 经营活动产生的现金流量净额/流动负债
     */
    @Column(name = "ocf_to_shortdebt")
    private Float ocfToShortdebt;

    /**
     * 产权比率
     */
    @Column(name = "debt_to_eqt")
    private Float debtToEqt;

    /**
     * 归属于母公司的股东权益/负债合计
     */
    @Column(name = "eqt_to_debt")
    private Float eqtToDebt;

    /**
     * 归属于母公司的股东权益/带息债务
     */
    @Column(name = "eqt_to_interestdebt")
    private Float eqtToInterestdebt;

    /**
     * 有形资产/负债合计
     */
    @Column(name = "tangibleasset_to_debt")
    private Float tangibleassetToDebt;

    /**
     * 有形资产/带息债务
     */
    @Column(name = "tangasset_to_intdebt")
    private Float tangassetToIntdebt;

    /**
     * 有形资产/净债务
     */
    @Column(name = "tangibleasset_to_netdebt")
    private Float tangibleassetToNetdebt;

    /**
     * 经营活动产生的现金流量净额/负债合计
     */
    @Column(name = "ocf_to_debt")
    private Float ocfToDebt;

    /**
     * 经营活动产生的现金流量净额/带息债务
     */
    @Column(name = "ocf_to_interestdebt")
    private Float ocfToInterestdebt;

    /**
     * 经营活动产生的现金流量净额/净债务
     */
    @Column(name = "ocf_to_netdebt")
    private Float ocfToNetdebt;

    /**
     * 已获利息倍数(EBIT/利息费用)
     */
    @Column(name = "ebit_to_interest")
    private Float ebitToInterest;

    /**
     * 长期债务与营运资金比率
     */
    @Column(name = "longdebt_to_workingcapital")
    private Float longdebtToWorkingcapital;

    /**
     * 息税折旧摊销前利润/负债合计
     */
    @Column(name = "ebitda_to_debt")
    private Float ebitdaToDebt;

    /**
     * 营业周期
     */
    @Column(name = "turn_days")
    private Float turnDays;

    /**
     * 年化总资产净利率
     */
    @Column(name = "roa_yearly")
    private Float roaYearly;

    /**
     * 总资产净利率(杜邦分析)
     */
    @Column(name = "roa_dp")
    private Float roaDp;

    /**
     * 固定资产合计
     */
    @Column(name = "fixed_assets")
    private Float fixedAssets;

    /**
     * 扣除财务费用前营业利润
     */
    @Column(name = "profit_prefin_exp")
    private Float profitPrefinExp;

    /**
     * 非营业利润
     */
    @Column(name = "non_op_profit")
    private Float nonOpProfit;

    /**
     * 营业利润／利润总额
     */
    @Column(name = "op_to_ebt")
    private Float opToEbt;

    /**
     * 非营业利润／利润总额
     */
    @Column(name = "nop_to_ebt")
    private Float nopToEbt;

    /**
     * 经营活动产生的现金流量净额／营业利润
     */
    @Column(name = "ocf_to_profit")
    private Float ocfToProfit;

    /**
     * 货币资金／流动负债
     */
    @Column(name = "cash_to_liqdebt")
    private Float cashToLiqdebt;

    /**
     * 货币资金／带息流动负债
     */
    @Column(name = "cash_to_liqdebt_withinterest")
    private Float cashToLiqdebtWithinterest;

    /**
     * 营业利润／流动负债
     */
    @Column(name = "op_to_liqdebt")
    private Float opToLiqdebt;

    /**
     * 营业利润／负债合计
     */
    @Column(name = "op_to_debt")
    private Float opToDebt;

    /**
     * 年化投入资本回报率
     */
    @Column(name = "roic_yearly")
    private Float roicYearly;

    /**
     * 固定资产合计周转率
     */
    @Column(name = "total_fa_trun")
    private Float totalFaTrun;

    /**
     * 利润总额／营业收入
     */
    @Column(name = "profit_to_op")
    private Float profitToOp;

    /**
     * 经营活动单季度净收益
     */
    @Column(name = "q_opincome")
    private Float qOpincome;

    /**
     * 价值变动单季度净收益
     */
    @Column(name = "q_investincome")
    private Float qInvestincome;

    /**
     * 扣除非经常损益后的单季度净利润
     */
    @Column(name = "q_dtprofit")
    private Float qDtprofit;

    /**
     * 每股收益(单季度)
     */
    @Column(name = "q_eps")
    private Float qEps;

    /**
     * 销售净利率(单季度)
     */
    @Column(name = "q_netprofit_margin")
    private Float qNetprofitMargin;

    /**
     * 销售毛利率(单季度)
     */
    @Column(name = "q_gsprofit_margin")
    private Float qGsprofitMargin;

    /**
     * 销售期间费用率(单季度)
     */
    @Column(name = "q_exp_to_sales")
    private Float qExpToSales;

    /**
     * 净利润／营业总收入(单季度)
     */
    @Column(name = "q_profit_to_gr")
    private Float qProfitToGr;

    /**
     * 销售费用／营业总收入 (单季度)
     */
    @Column(name = "q_saleexp_to_gr")
    private Float qSaleexpToGr;

    /**
     * 管理费用／营业总收入 (单季度)
     */
    @Column(name = "q_adminexp_to_gr")
    private Float qAdminexpToGr;

    /**
     * 财务费用／营业总收入 (单季度)
     */
    @Column(name = "q_finaexp_to_gr")
    private Float qFinaexpToGr;

    /**
     * 资产减值损失／营业总收入(单季度)
     */
    @Column(name = "q_impair_to_gr_ttm")
    private Float qImpairToGrTtm;

    /**
     * 营业总成本／营业总收入 (单季度)
     */
    @Column(name = "q_gc_to_gr")
    private Float qGcToGr;

    /**
     * 营业利润／营业总收入(单季度)
     */
    @Column(name = "q_op_to_gr")
    private Float qOpToGr;

    /**
     * 净资产收益率(单季度)
     */
    @Column(name = "q_roe")
    private Float qRoe;

    /**
     * 净资产单季度收益率(扣除非经常损益)
     */
    @Column(name = "q_dt_roe")
    private Float qDtRoe;

    /**
     * 总资产净利润(单季度)
     */
    @Column(name = "q_npta")
    private Float qNpta;

    /**
     * 经营活动净收益／利润总额(单季度)
     */
    @Column(name = "q_opincome_to_ebt")
    private Float qOpincomeToEbt;

    /**
     * 价值变动净收益／利润总额(单季度)
     */
    @Column(name = "q_investincome_to_ebt")
    private Float qInvestincomeToEbt;

    /**
     * 扣除非经常损益后的净利润／净利润(单季度)
     */
    @Column(name = "q_dtprofit_to_profit")
    private Float qDtprofitToProfit;

    /**
     * 销售商品提供劳务收到的现金／营业收入(单季度)
     */
    @Column(name = "q_salescash_to_or")
    private Float qSalescashToOr;

    /**
     * 经营活动产生的现金流量净额／营业收入(单季度)
     */
    @Column(name = "q_ocf_to_sales")
    private Float qOcfToSales;

    /**
     * 经营活动产生的现金流量净额／经营活动净收益(单季度)
     */
    @Column(name = "q_ocf_to_or")
    private Float qOcfToOr;

    /**
     * 基本每股收益同比增长率(%)
     */
    @Column(name = "basic_eps_yoy")
    private Float basicEpsYoy;

    /**
     * 稀释每股收益同比增长率(%)
     */
    @Column(name = "dt_eps_yoy")
    private Float dtEpsYoy;

    /**
     * 每股经营活动产生的现金流量净额同比增长率(%)
     */
    @Column(name = "cfps_yoy")
    private Float cfpsYoy;

    /**
     * 营业利润同比增长率(%)
     */
    @Column(name = "op_yoy")
    private Float opYoy;

    /**
     * 利润总额同比增长率(%)
     */
    @Column(name = "ebt_yoy")
    private Float ebtYoy;

    /**
     * 归属母公司股东的净利润同比增长率(%)
     */
    @Column(name = "netprofit_yoy")
    private Float netprofitYoy;

    /**
     * 归属母公司股东的净利润-扣除非经常损益同比增长率(%)
     */
    @Column(name = "dt_netprofit_yoy")
    private Float dtNetprofitYoy;

    /**
     * 经营活动产生的现金流量净额同比增长率(%)
     */
    @Column(name = "ocf_yoy")
    private Float ocfYoy;

    /**
     * 净资产收益率(摊薄)同比增长率(%)
     */
    @Column(name = "roe_yoy")
    private Float roeYoy;

    /**
     * 每股净资产相对年初增长率(%)
     */
    @Column(name = "bps_yoy")
    private Float bpsYoy;

    /**
     * 资产总计相对年初增长率(%)
     */
    @Column(name = "assets_yoy")
    private Float assetsYoy;

    /**
     * 归属母公司的股东权益相对年初增长率(%)
     */
    @Column(name = "eqt_yoy")
    private Float eqtYoy;

    /**
     * 营业总收入同比增长率(%)
     */
    @Column(name = "tr_yoy")
    private Float trYoy;

    /**
     * 营业收入同比增长率(%)
     */
    @Column(name = "or_yoy")
    private Float orYoy;

    /**
     * 营业总收入同比增长率(%)(单季度)
     */
    @Column(name = "q_gr_yoy")
    private Float qGrYoy;

    /**
     * 营业总收入环比增长率(%)(单季度)
     */
    @Column(name = "q_gr_qoq")
    private Float qGrQoq;

    /**
     * 营业收入同比增长率(%)(单季度)
     */
    @Column(name = "q_sales_yoy")
    private Float qSalesYoy;

    /**
     * 营业收入环比增长率(%)(单季度)
     */
    @Column(name = "q_sales_qoq")
    private Float qSalesQoq;

    /**
     * 营业利润同比增长率(%)(单季度)
     */
    @Column(name = "q_op_yoy")
    private Float qOpYoy;

    /**
     * 营业利润环比增长率(%)(单季度)
     */
    @Column(name = "q_op_qoq")
    private Float qOpQoq;

    /**
     * 净利润同比增长率(%)(单季度)
     */
    @Column(name = "q_profit_yoy")
    private Float qProfitYoy;

    /**
     * 净利润环比增长率(%)(单季度)
     */
    @Column(name = "q_profit_qoq")
    private Float qProfitQoq;

    /**
     * 归属母公司股东的净利润同比增长率(%)(单季度)
     */
    @Column(name = "q_netprofit_yoy")
    private Float qNetprofitYoy;

    /**
     * 归属母公司股东的净利润环比增长率(%)(单季度)
     */
    @Column(name = "q_netprofit_qoq")
    private Float qNetprofitQoq;

    /**
     * 净资产同比增长率
     */
    @Column(name = "equity_yoy")
    private Float equityYoy;

    /**
     * 研发费用
     */
    @Column(name = "rd_exp")
    private Float rdExp;

    /**
     * 更新标识
     */
    @Column(name = "update_flag")
    private String updateFlag;

    public FFinaIndicator(Long tid, String tsCode, String annDate, String endDate, Float eps, Float dtEps, Float totalRevenuePs, Float revenuePs, Float capitalResePs, Float surplusResePs, Float undistProfitPs, Float extraItem, Float profitDedt, Float grossMargin, Float currentRatio, Float quickRatio, Float cashRatio, Float invturnDays, Float arturnDays, Float invTurn, Float arTurn, Float caTurn, Float faTurn, Float assetsTurn, Float opIncome, Float valuechangeIncome, Float interstIncome, Float daa, Float ebit, Float ebitda, Float fcff, Float fcfe, Float currentExint, Float noncurrentExint, Float interestdebt, Float netdebt, Float tangibleAsset, Float workingCapital, Float networkingCapital, Float investCapital, Float retainedEarnings, Float diluted2Eps, Float bps, Float ocfps, Float retainedps, Float cfps, Float ebitPs, Float fcffPs, Float fcfePs, Float netprofitMargin, Float grossprofitMargin, Float cogsOfSales, Float expenseOfSales, Float profitToGr, Float saleexpToGr, Float adminexpOfGr, Float finaexpOfGr, Float impaiTtm, Float gcOfGr, Float opOfGr, Float ebitOfGr, Float roe, Float roeWaa, Float roeDt, Float roa, Float npta, Float roic, Float roeYearly, Float roa2Yearly, Float roeAvg, Float opincomeOfEbt, Float investincomeOfEbt, Float nOpProfitOfEbt, Float taxToEbt, Float dtprofitToProfit, Float salescashToOr, Float ocfToOr, Float ocfToOpincome, Float capitalizedToDa, Float debtToAssets, Float assetsToEqt, Float dpAssetsToEqt, Float caToAssets, Float ncaToAssets, Float tbassetsToTotalassets, Float intToTalcap, Float eqtToTalcapital, Float currentdebtToDebt, Float longdebToDebt, Float ocfToShortdebt, Float debtToEqt, Float eqtToDebt, Float eqtToInterestdebt, Float tangibleassetToDebt, Float tangassetToIntdebt, Float tangibleassetToNetdebt, Float ocfToDebt, Float ocfToInterestdebt, Float ocfToNetdebt, Float ebitToInterest, Float longdebtToWorkingcapital, Float ebitdaToDebt, Float turnDays, Float roaYearly, Float roaDp, Float fixedAssets, Float profitPrefinExp, Float nonOpProfit, Float opToEbt, Float nopToEbt, Float ocfToProfit, Float cashToLiqdebt, Float cashToLiqdebtWithinterest, Float opToLiqdebt, Float opToDebt, Float roicYearly, Float totalFaTrun, Float profitToOp, Float qOpincome, Float qInvestincome, Float qDtprofit, Float qEps, Float qNetprofitMargin, Float qGsprofitMargin, Float qExpToSales, Float qProfitToGr, Float qSaleexpToGr, Float qAdminexpToGr, Float qFinaexpToGr, Float qImpairToGrTtm, Float qGcToGr, Float qOpToGr, Float qRoe, Float qDtRoe, Float qNpta, Float qOpincomeToEbt, Float qInvestincomeToEbt, Float qDtprofitToProfit, Float qSalescashToOr, Float qOcfToSales, Float qOcfToOr, Float basicEpsYoy, Float dtEpsYoy, Float cfpsYoy, Float opYoy, Float ebtYoy, Float netprofitYoy, Float dtNetprofitYoy, Float ocfYoy, Float roeYoy, Float bpsYoy, Float assetsYoy, Float eqtYoy, Float trYoy, Float orYoy, Float qGrYoy, Float qGrQoq, Float qSalesYoy, Float qSalesQoq, Float qOpYoy, Float qOpQoq, Float qProfitYoy, Float qProfitQoq, Float qNetprofitYoy, Float qNetprofitQoq, Float equityYoy, Float rdExp, String updateFlag) {
        this.tid = tid;
        this.tsCode = tsCode;
        this.annDate = annDate;
        this.endDate = endDate;
        this.eps = eps;
        this.dtEps = dtEps;
        this.totalRevenuePs = totalRevenuePs;
        this.revenuePs = revenuePs;
        this.capitalResePs = capitalResePs;
        this.surplusResePs = surplusResePs;
        this.undistProfitPs = undistProfitPs;
        this.extraItem = extraItem;
        this.profitDedt = profitDedt;
        this.grossMargin = grossMargin;
        this.currentRatio = currentRatio;
        this.quickRatio = quickRatio;
        this.cashRatio = cashRatio;
        this.invturnDays = invturnDays;
        this.arturnDays = arturnDays;
        this.invTurn = invTurn;
        this.arTurn = arTurn;
        this.caTurn = caTurn;
        this.faTurn = faTurn;
        this.assetsTurn = assetsTurn;
        this.opIncome = opIncome;
        this.valuechangeIncome = valuechangeIncome;
        this.interstIncome = interstIncome;
        this.daa = daa;
        this.ebit = ebit;
        this.ebitda = ebitda;
        this.fcff = fcff;
        this.fcfe = fcfe;
        this.currentExint = currentExint;
        this.noncurrentExint = noncurrentExint;
        this.interestdebt = interestdebt;
        this.netdebt = netdebt;
        this.tangibleAsset = tangibleAsset;
        this.workingCapital = workingCapital;
        this.networkingCapital = networkingCapital;
        this.investCapital = investCapital;
        this.retainedEarnings = retainedEarnings;
        this.diluted2Eps = diluted2Eps;
        this.bps = bps;
        this.ocfps = ocfps;
        this.retainedps = retainedps;
        this.cfps = cfps;
        this.ebitPs = ebitPs;
        this.fcffPs = fcffPs;
        this.fcfePs = fcfePs;
        this.netprofitMargin = netprofitMargin;
        this.grossprofitMargin = grossprofitMargin;
        this.cogsOfSales = cogsOfSales;
        this.expenseOfSales = expenseOfSales;
        this.profitToGr = profitToGr;
        this.saleexpToGr = saleexpToGr;
        this.adminexpOfGr = adminexpOfGr;
        this.finaexpOfGr = finaexpOfGr;
        this.impaiTtm = impaiTtm;
        this.gcOfGr = gcOfGr;
        this.opOfGr = opOfGr;
        this.ebitOfGr = ebitOfGr;
        this.roe = roe;
        this.roeWaa = roeWaa;
        this.roeDt = roeDt;
        this.roa = roa;
        this.npta = npta;
        this.roic = roic;
        this.roeYearly = roeYearly;
        this.roa2Yearly = roa2Yearly;
        this.roeAvg = roeAvg;
        this.opincomeOfEbt = opincomeOfEbt;
        this.investincomeOfEbt = investincomeOfEbt;
        this.nOpProfitOfEbt = nOpProfitOfEbt;
        this.taxToEbt = taxToEbt;
        this.dtprofitToProfit = dtprofitToProfit;
        this.salescashToOr = salescashToOr;
        this.ocfToOr = ocfToOr;
        this.ocfToOpincome = ocfToOpincome;
        this.capitalizedToDa = capitalizedToDa;
        this.debtToAssets = debtToAssets;
        this.assetsToEqt = assetsToEqt;
        this.dpAssetsToEqt = dpAssetsToEqt;
        this.caToAssets = caToAssets;
        this.ncaToAssets = ncaToAssets;
        this.tbassetsToTotalassets = tbassetsToTotalassets;
        this.intToTalcap = intToTalcap;
        this.eqtToTalcapital = eqtToTalcapital;
        this.currentdebtToDebt = currentdebtToDebt;
        this.longdebToDebt = longdebToDebt;
        this.ocfToShortdebt = ocfToShortdebt;
        this.debtToEqt = debtToEqt;
        this.eqtToDebt = eqtToDebt;
        this.eqtToInterestdebt = eqtToInterestdebt;
        this.tangibleassetToDebt = tangibleassetToDebt;
        this.tangassetToIntdebt = tangassetToIntdebt;
        this.tangibleassetToNetdebt = tangibleassetToNetdebt;
        this.ocfToDebt = ocfToDebt;
        this.ocfToInterestdebt = ocfToInterestdebt;
        this.ocfToNetdebt = ocfToNetdebt;
        this.ebitToInterest = ebitToInterest;
        this.longdebtToWorkingcapital = longdebtToWorkingcapital;
        this.ebitdaToDebt = ebitdaToDebt;
        this.turnDays = turnDays;
        this.roaYearly = roaYearly;
        this.roaDp = roaDp;
        this.fixedAssets = fixedAssets;
        this.profitPrefinExp = profitPrefinExp;
        this.nonOpProfit = nonOpProfit;
        this.opToEbt = opToEbt;
        this.nopToEbt = nopToEbt;
        this.ocfToProfit = ocfToProfit;
        this.cashToLiqdebt = cashToLiqdebt;
        this.cashToLiqdebtWithinterest = cashToLiqdebtWithinterest;
        this.opToLiqdebt = opToLiqdebt;
        this.opToDebt = opToDebt;
        this.roicYearly = roicYearly;
        this.totalFaTrun = totalFaTrun;
        this.profitToOp = profitToOp;
        this.qOpincome = qOpincome;
        this.qInvestincome = qInvestincome;
        this.qDtprofit = qDtprofit;
        this.qEps = qEps;
        this.qNetprofitMargin = qNetprofitMargin;
        this.qGsprofitMargin = qGsprofitMargin;
        this.qExpToSales = qExpToSales;
        this.qProfitToGr = qProfitToGr;
        this.qSaleexpToGr = qSaleexpToGr;
        this.qAdminexpToGr = qAdminexpToGr;
        this.qFinaexpToGr = qFinaexpToGr;
        this.qImpairToGrTtm = qImpairToGrTtm;
        this.qGcToGr = qGcToGr;
        this.qOpToGr = qOpToGr;
        this.qRoe = qRoe;
        this.qDtRoe = qDtRoe;
        this.qNpta = qNpta;
        this.qOpincomeToEbt = qOpincomeToEbt;
        this.qInvestincomeToEbt = qInvestincomeToEbt;
        this.qDtprofitToProfit = qDtprofitToProfit;
        this.qSalescashToOr = qSalescashToOr;
        this.qOcfToSales = qOcfToSales;
        this.qOcfToOr = qOcfToOr;
        this.basicEpsYoy = basicEpsYoy;
        this.dtEpsYoy = dtEpsYoy;
        this.cfpsYoy = cfpsYoy;
        this.opYoy = opYoy;
        this.ebtYoy = ebtYoy;
        this.netprofitYoy = netprofitYoy;
        this.dtNetprofitYoy = dtNetprofitYoy;
        this.ocfYoy = ocfYoy;
        this.roeYoy = roeYoy;
        this.bpsYoy = bpsYoy;
        this.assetsYoy = assetsYoy;
        this.eqtYoy = eqtYoy;
        this.trYoy = trYoy;
        this.orYoy = orYoy;
        this.qGrYoy = qGrYoy;
        this.qGrQoq = qGrQoq;
        this.qSalesYoy = qSalesYoy;
        this.qSalesQoq = qSalesQoq;
        this.qOpYoy = qOpYoy;
        this.qOpQoq = qOpQoq;
        this.qProfitYoy = qProfitYoy;
        this.qProfitQoq = qProfitQoq;
        this.qNetprofitYoy = qNetprofitYoy;
        this.qNetprofitQoq = qNetprofitQoq;
        this.equityYoy = equityYoy;
        this.rdExp = rdExp;
        this.updateFlag = updateFlag;
    }

    public FFinaIndicator() {
        super();
    }

    /**
     * @return tid
     */
    public Long getTid() {
        return tid;
    }

    /**
     * @param tid
     */
    public void setTid(Long tid) {
        this.tid = tid;
    }

    /**
     * 获取TS代码
     *
     * @return ts_code - TS代码
     */
    public String getTsCode() {
        return tsCode;
    }

    /**
     * 设置TS代码
     *
     * @param tsCode TS代码
     */
    public void setTsCode(String tsCode) {
        this.tsCode = tsCode;
    }

    /**
     * 获取公告日期
     *
     * @return ann_date - 公告日期
     */
    public String getAnnDate() {
        return annDate;
    }

    /**
     * 设置公告日期
     *
     * @param annDate 公告日期
     */
    public void setAnnDate(String annDate) {
        this.annDate = annDate;
    }

    /**
     * 获取报告期
     *
     * @return end_date - 报告期
     */
    public String getEndDate() {
        return endDate;
    }

    /**
     * 设置报告期
     *
     * @param endDate 报告期
     */
    public void setEndDate(String endDate) {
        this.endDate = endDate;
    }

    /**
     * 获取基本每股收益
     *
     * @return eps - 基本每股收益
     */
    public Float getEps() {
        return eps;
    }

    /**
     * 设置基本每股收益
     *
     * @param eps 基本每股收益
     */
    public void setEps(Float eps) {
        this.eps = eps;
    }

    /**
     * 获取稀释每股收益
     *
     * @return dt_eps - 稀释每股收益
     */
    public Float getDtEps() {
        return dtEps;
    }

    /**
     * 设置稀释每股收益
     *
     * @param dtEps 稀释每股收益
     */
    public void setDtEps(Float dtEps) {
        this.dtEps = dtEps;
    }

    /**
     * 获取每股营业总收入
     *
     * @return total_revenue_ps - 每股营业总收入
     */
    public Float getTotalRevenuePs() {
        return totalRevenuePs;
    }

    /**
     * 设置每股营业总收入
     *
     * @param totalRevenuePs 每股营业总收入
     */
    public void setTotalRevenuePs(Float totalRevenuePs) {
        this.totalRevenuePs = totalRevenuePs;
    }

    /**
     * 获取每股营业收入
     *
     * @return revenue_ps - 每股营业收入
     */
    public Float getRevenuePs() {
        return revenuePs;
    }

    /**
     * 设置每股营业收入
     *
     * @param revenuePs 每股营业收入
     */
    public void setRevenuePs(Float revenuePs) {
        this.revenuePs = revenuePs;
    }

    /**
     * 获取每股资本公积
     *
     * @return capital_rese_ps - 每股资本公积
     */
    public Float getCapitalResePs() {
        return capitalResePs;
    }

    /**
     * 设置每股资本公积
     *
     * @param capitalResePs 每股资本公积
     */
    public void setCapitalResePs(Float capitalResePs) {
        this.capitalResePs = capitalResePs;
    }

    /**
     * 获取每股盈余公积
     *
     * @return surplus_rese_ps - 每股盈余公积
     */
    public Float getSurplusResePs() {
        return surplusResePs;
    }

    /**
     * 设置每股盈余公积
     *
     * @param surplusResePs 每股盈余公积
     */
    public void setSurplusResePs(Float surplusResePs) {
        this.surplusResePs = surplusResePs;
    }

    /**
     * 获取每股未分配利润
     *
     * @return undist_profit_ps - 每股未分配利润
     */
    public Float getUndistProfitPs() {
        return undistProfitPs;
    }

    /**
     * 设置每股未分配利润
     *
     * @param undistProfitPs 每股未分配利润
     */
    public void setUndistProfitPs(Float undistProfitPs) {
        this.undistProfitPs = undistProfitPs;
    }

    /**
     * 获取非经常性损益
     *
     * @return extra_item - 非经常性损益
     */
    public Float getExtraItem() {
        return extraItem;
    }

    /**
     * 设置非经常性损益
     *
     * @param extraItem 非经常性损益
     */
    public void setExtraItem(Float extraItem) {
        this.extraItem = extraItem;
    }

    /**
     * 获取扣除非经常性损益后的净利润
     *
     * @return profit_dedt - 扣除非经常性损益后的净利润
     */
    public Float getProfitDedt() {
        return profitDedt;
    }

    /**
     * 设置扣除非经常性损益后的净利润
     *
     * @param profitDedt 扣除非经常性损益后的净利润
     */
    public void setProfitDedt(Float profitDedt) {
        this.profitDedt = profitDedt;
    }

    /**
     * 获取毛利
     *
     * @return gross_margin - 毛利
     */
    public Float getGrossMargin() {
        return grossMargin;
    }

    /**
     * 设置毛利
     *
     * @param grossMargin 毛利
     */
    public void setGrossMargin(Float grossMargin) {
        this.grossMargin = grossMargin;
    }

    /**
     * 获取流动比率
     *
     * @return current_ratio - 流动比率
     */
    public Float getCurrentRatio() {
        return currentRatio;
    }

    /**
     * 设置流动比率
     *
     * @param currentRatio 流动比率
     */
    public void setCurrentRatio(Float currentRatio) {
        this.currentRatio = currentRatio;
    }

    /**
     * 获取速动比率
     *
     * @return quick_ratio - 速动比率
     */
    public Float getQuickRatio() {
        return quickRatio;
    }

    /**
     * 设置速动比率
     *
     * @param quickRatio 速动比率
     */
    public void setQuickRatio(Float quickRatio) {
        this.quickRatio = quickRatio;
    }

    /**
     * 获取保守速动比率
     *
     * @return cash_ratio - 保守速动比率
     */
    public Float getCashRatio() {
        return cashRatio;
    }

    /**
     * 设置保守速动比率
     *
     * @param cashRatio 保守速动比率
     */
    public void setCashRatio(Float cashRatio) {
        this.cashRatio = cashRatio;
    }

    /**
     * 获取存货周转天数
     *
     * @return invturn_days - 存货周转天数
     */
    public Float getInvturnDays() {
        return invturnDays;
    }

    /**
     * 设置存货周转天数
     *
     * @param invturnDays 存货周转天数
     */
    public void setInvturnDays(Float invturnDays) {
        this.invturnDays = invturnDays;
    }

    /**
     * 获取应收账款周转天数
     *
     * @return arturn_days - 应收账款周转天数
     */
    public Float getArturnDays() {
        return arturnDays;
    }

    /**
     * 设置应收账款周转天数
     *
     * @param arturnDays 应收账款周转天数
     */
    public void setArturnDays(Float arturnDays) {
        this.arturnDays = arturnDays;
    }

    /**
     * 获取存货周转率
     *
     * @return inv_turn - 存货周转率
     */
    public Float getInvTurn() {
        return invTurn;
    }

    /**
     * 设置存货周转率
     *
     * @param invTurn 存货周转率
     */
    public void setInvTurn(Float invTurn) {
        this.invTurn = invTurn;
    }

    /**
     * 获取应收账款周转率
     *
     * @return ar_turn - 应收账款周转率
     */
    public Float getArTurn() {
        return arTurn;
    }

    /**
     * 设置应收账款周转率
     *
     * @param arTurn 应收账款周转率
     */
    public void setArTurn(Float arTurn) {
        this.arTurn = arTurn;
    }

    /**
     * 获取流动资产周转率
     *
     * @return ca_turn - 流动资产周转率
     */
    public Float getCaTurn() {
        return caTurn;
    }

    /**
     * 设置流动资产周转率
     *
     * @param caTurn 流动资产周转率
     */
    public void setCaTurn(Float caTurn) {
        this.caTurn = caTurn;
    }

    /**
     * 获取固定资产周转率
     *
     * @return fa_turn - 固定资产周转率
     */
    public Float getFaTurn() {
        return faTurn;
    }

    /**
     * 设置固定资产周转率
     *
     * @param faTurn 固定资产周转率
     */
    public void setFaTurn(Float faTurn) {
        this.faTurn = faTurn;
    }

    /**
     * 获取总资产周转率
     *
     * @return assets_turn - 总资产周转率
     */
    public Float getAssetsTurn() {
        return assetsTurn;
    }

    /**
     * 设置总资产周转率
     *
     * @param assetsTurn 总资产周转率
     */
    public void setAssetsTurn(Float assetsTurn) {
        this.assetsTurn = assetsTurn;
    }

    /**
     * 获取经营活动净收益
     *
     * @return op_income - 经营活动净收益
     */
    public Float getOpIncome() {
        return opIncome;
    }

    /**
     * 设置经营活动净收益
     *
     * @param opIncome 经营活动净收益
     */
    public void setOpIncome(Float opIncome) {
        this.opIncome = opIncome;
    }

    /**
     * 获取价值变动净收益
     *
     * @return valuechange_income - 价值变动净收益
     */
    public Float getValuechangeIncome() {
        return valuechangeIncome;
    }

    /**
     * 设置价值变动净收益
     *
     * @param valuechangeIncome 价值变动净收益
     */
    public void setValuechangeIncome(Float valuechangeIncome) {
        this.valuechangeIncome = valuechangeIncome;
    }

    /**
     * 获取利息费用
     *
     * @return interst_income - 利息费用
     */
    public Float getInterstIncome() {
        return interstIncome;
    }

    /**
     * 设置利息费用
     *
     * @param interstIncome 利息费用
     */
    public void setInterstIncome(Float interstIncome) {
        this.interstIncome = interstIncome;
    }

    /**
     * 获取折旧与摊销
     *
     * @return daa - 折旧与摊销
     */
    public Float getDaa() {
        return daa;
    }

    /**
     * 设置折旧与摊销
     *
     * @param daa 折旧与摊销
     */
    public void setDaa(Float daa) {
        this.daa = daa;
    }

    /**
     * 获取息税前利润
     *
     * @return ebit - 息税前利润
     */
    public Float getEbit() {
        return ebit;
    }

    /**
     * 设置息税前利润
     *
     * @param ebit 息税前利润
     */
    public void setEbit(Float ebit) {
        this.ebit = ebit;
    }

    /**
     * 获取息税折旧摊销前利润
     *
     * @return ebitda - 息税折旧摊销前利润
     */
    public Float getEbitda() {
        return ebitda;
    }

    /**
     * 设置息税折旧摊销前利润
     *
     * @param ebitda 息税折旧摊销前利润
     */
    public void setEbitda(Float ebitda) {
        this.ebitda = ebitda;
    }

    /**
     * 获取企业自由现金流量
     *
     * @return fcff - 企业自由现金流量
     */
    public Float getFcff() {
        return fcff;
    }

    /**
     * 设置企业自由现金流量
     *
     * @param fcff 企业自由现金流量
     */
    public void setFcff(Float fcff) {
        this.fcff = fcff;
    }

    /**
     * 获取股权自由现金流量
     *
     * @return fcfe - 股权自由现金流量
     */
    public Float getFcfe() {
        return fcfe;
    }

    /**
     * 设置股权自由现金流量
     *
     * @param fcfe 股权自由现金流量
     */
    public void setFcfe(Float fcfe) {
        this.fcfe = fcfe;
    }

    /**
     * 获取无息流动负债
     *
     * @return current_exint - 无息流动负债
     */
    public Float getCurrentExint() {
        return currentExint;
    }

    /**
     * 设置无息流动负债
     *
     * @param currentExint 无息流动负债
     */
    public void setCurrentExint(Float currentExint) {
        this.currentExint = currentExint;
    }

    /**
     * 获取无息非流动负债
     *
     * @return noncurrent_exint - 无息非流动负债
     */
    public Float getNoncurrentExint() {
        return noncurrentExint;
    }

    /**
     * 设置无息非流动负债
     *
     * @param noncurrentExint 无息非流动负债
     */
    public void setNoncurrentExint(Float noncurrentExint) {
        this.noncurrentExint = noncurrentExint;
    }

    /**
     * 获取带息债务
     *
     * @return interestdebt - 带息债务
     */
    public Float getInterestdebt() {
        return interestdebt;
    }

    /**
     * 设置带息债务
     *
     * @param interestdebt 带息债务
     */
    public void setInterestdebt(Float interestdebt) {
        this.interestdebt = interestdebt;
    }

    /**
     * 获取净债务
     *
     * @return netdebt - 净债务
     */
    public Float getNetdebt() {
        return netdebt;
    }

    /**
     * 设置净债务
     *
     * @param netdebt 净债务
     */
    public void setNetdebt(Float netdebt) {
        this.netdebt = netdebt;
    }

    /**
     * 获取有形资产
     *
     * @return tangible_asset - 有形资产
     */
    public Float getTangibleAsset() {
        return tangibleAsset;
    }

    /**
     * 设置有形资产
     *
     * @param tangibleAsset 有形资产
     */
    public void setTangibleAsset(Float tangibleAsset) {
        this.tangibleAsset = tangibleAsset;
    }

    /**
     * 获取营运资金
     *
     * @return working_capital - 营运资金
     */
    public Float getWorkingCapital() {
        return workingCapital;
    }

    /**
     * 设置营运资金
     *
     * @param workingCapital 营运资金
     */
    public void setWorkingCapital(Float workingCapital) {
        this.workingCapital = workingCapital;
    }

    /**
     * 获取营运流动资本
     *
     * @return networking_capital - 营运流动资本
     */
    public Float getNetworkingCapital() {
        return networkingCapital;
    }

    /**
     * 设置营运流动资本
     *
     * @param networkingCapital 营运流动资本
     */
    public void setNetworkingCapital(Float networkingCapital) {
        this.networkingCapital = networkingCapital;
    }

    /**
     * 获取全部投入资本
     *
     * @return invest_capital - 全部投入资本
     */
    public Float getInvestCapital() {
        return investCapital;
    }

    /**
     * 设置全部投入资本
     *
     * @param investCapital 全部投入资本
     */
    public void setInvestCapital(Float investCapital) {
        this.investCapital = investCapital;
    }

    /**
     * 获取留存收益
     *
     * @return retained_earnings - 留存收益
     */
    public Float getRetainedEarnings() {
        return retainedEarnings;
    }

    /**
     * 设置留存收益
     *
     * @param retainedEarnings 留存收益
     */
    public void setRetainedEarnings(Float retainedEarnings) {
        this.retainedEarnings = retainedEarnings;
    }

    /**
     * 获取期末摊薄每股收益
     *
     * @return diluted2_eps - 期末摊薄每股收益
     */
    public Float getDiluted2Eps() {
        return diluted2Eps;
    }

    /**
     * 设置期末摊薄每股收益
     *
     * @param diluted2Eps 期末摊薄每股收益
     */
    public void setDiluted2Eps(Float diluted2Eps) {
        this.diluted2Eps = diluted2Eps;
    }

    /**
     * 获取每股净资产
     *
     * @return bps - 每股净资产
     */
    public Float getBps() {
        return bps;
    }

    /**
     * 设置每股净资产
     *
     * @param bps 每股净资产
     */
    public void setBps(Float bps) {
        this.bps = bps;
    }

    /**
     * 获取每股经营活动产生的现金流量净额
     *
     * @return ocfps - 每股经营活动产生的现金流量净额
     */
    public Float getOcfps() {
        return ocfps;
    }

    /**
     * 设置每股经营活动产生的现金流量净额
     *
     * @param ocfps 每股经营活动产生的现金流量净额
     */
    public void setOcfps(Float ocfps) {
        this.ocfps = ocfps;
    }

    /**
     * 获取每股留存收益
     *
     * @return retainedps - 每股留存收益
     */
    public Float getRetainedps() {
        return retainedps;
    }

    /**
     * 设置每股留存收益
     *
     * @param retainedps 每股留存收益
     */
    public void setRetainedps(Float retainedps) {
        this.retainedps = retainedps;
    }

    /**
     * 获取每股现金流量净额
     *
     * @return cfps - 每股现金流量净额
     */
    public Float getCfps() {
        return cfps;
    }

    /**
     * 设置每股现金流量净额
     *
     * @param cfps 每股现金流量净额
     */
    public void setCfps(Float cfps) {
        this.cfps = cfps;
    }

    /**
     * 获取每股息税前利润
     *
     * @return ebit_ps - 每股息税前利润
     */
    public Float getEbitPs() {
        return ebitPs;
    }

    /**
     * 设置每股息税前利润
     *
     * @param ebitPs 每股息税前利润
     */
    public void setEbitPs(Float ebitPs) {
        this.ebitPs = ebitPs;
    }

    /**
     * 获取每股企业自由现金流量
     *
     * @return fcff_ps - 每股企业自由现金流量
     */
    public Float getFcffPs() {
        return fcffPs;
    }

    /**
     * 设置每股企业自由现金流量
     *
     * @param fcffPs 每股企业自由现金流量
     */
    public void setFcffPs(Float fcffPs) {
        this.fcffPs = fcffPs;
    }

    /**
     * 获取每股股东自由现金流量
     *
     * @return fcfe_ps - 每股股东自由现金流量
     */
    public Float getFcfePs() {
        return fcfePs;
    }

    /**
     * 设置每股股东自由现金流量
     *
     * @param fcfePs 每股股东自由现金流量
     */
    public void setFcfePs(Float fcfePs) {
        this.fcfePs = fcfePs;
    }

    /**
     * 获取销售净利率
     *
     * @return netprofit_margin - 销售净利率
     */
    public Float getNetprofitMargin() {
        return netprofitMargin;
    }

    /**
     * 设置销售净利率
     *
     * @param netprofitMargin 销售净利率
     */
    public void setNetprofitMargin(Float netprofitMargin) {
        this.netprofitMargin = netprofitMargin;
    }

    /**
     * 获取销售毛利率
     *
     * @return grossprofit_margin - 销售毛利率
     */
    public Float getGrossprofitMargin() {
        return grossprofitMargin;
    }

    /**
     * 设置销售毛利率
     *
     * @param grossprofitMargin 销售毛利率
     */
    public void setGrossprofitMargin(Float grossprofitMargin) {
        this.grossprofitMargin = grossprofitMargin;
    }

    /**
     * 获取销售成本率
     *
     * @return cogs_of_sales - 销售成本率
     */
    public Float getCogsOfSales() {
        return cogsOfSales;
    }

    /**
     * 设置销售成本率
     *
     * @param cogsOfSales 销售成本率
     */
    public void setCogsOfSales(Float cogsOfSales) {
        this.cogsOfSales = cogsOfSales;
    }

    /**
     * 获取销售期间费用率
     *
     * @return expense_of_sales - 销售期间费用率
     */
    public Float getExpenseOfSales() {
        return expenseOfSales;
    }

    /**
     * 设置销售期间费用率
     *
     * @param expenseOfSales 销售期间费用率
     */
    public void setExpenseOfSales(Float expenseOfSales) {
        this.expenseOfSales = expenseOfSales;
    }

    /**
     * 获取净利润/营业总收入
     *
     * @return profit_to_gr - 净利润/营业总收入
     */
    public Float getProfitToGr() {
        return profitToGr;
    }

    /**
     * 设置净利润/营业总收入
     *
     * @param profitToGr 净利润/营业总收入
     */
    public void setProfitToGr(Float profitToGr) {
        this.profitToGr = profitToGr;
    }

    /**
     * 获取销售费用/营业总收入
     *
     * @return saleexp_to_gr - 销售费用/营业总收入
     */
    public Float getSaleexpToGr() {
        return saleexpToGr;
    }

    /**
     * 设置销售费用/营业总收入
     *
     * @param saleexpToGr 销售费用/营业总收入
     */
    public void setSaleexpToGr(Float saleexpToGr) {
        this.saleexpToGr = saleexpToGr;
    }

    /**
     * 获取管理费用/营业总收入
     *
     * @return adminexp_of_gr - 管理费用/营业总收入
     */
    public Float getAdminexpOfGr() {
        return adminexpOfGr;
    }

    /**
     * 设置管理费用/营业总收入
     *
     * @param adminexpOfGr 管理费用/营业总收入
     */
    public void setAdminexpOfGr(Float adminexpOfGr) {
        this.adminexpOfGr = adminexpOfGr;
    }

    /**
     * 获取财务费用/营业总收入
     *
     * @return finaexp_of_gr - 财务费用/营业总收入
     */
    public Float getFinaexpOfGr() {
        return finaexpOfGr;
    }

    /**
     * 设置财务费用/营业总收入
     *
     * @param finaexpOfGr 财务费用/营业总收入
     */
    public void setFinaexpOfGr(Float finaexpOfGr) {
        this.finaexpOfGr = finaexpOfGr;
    }

    /**
     * 获取资产减值损失/营业总收入
     *
     * @return impai_ttm - 资产减值损失/营业总收入
     */
    public Float getImpaiTtm() {
        return impaiTtm;
    }

    /**
     * 设置资产减值损失/营业总收入
     *
     * @param impaiTtm 资产减值损失/营业总收入
     */
    public void setImpaiTtm(Float impaiTtm) {
        this.impaiTtm = impaiTtm;
    }

    /**
     * 获取营业总成本/营业总收入
     *
     * @return gc_of_gr - 营业总成本/营业总收入
     */
    public Float getGcOfGr() {
        return gcOfGr;
    }

    /**
     * 设置营业总成本/营业总收入
     *
     * @param gcOfGr 营业总成本/营业总收入
     */
    public void setGcOfGr(Float gcOfGr) {
        this.gcOfGr = gcOfGr;
    }

    /**
     * 获取营业利润/营业总收入
     *
     * @return op_of_gr - 营业利润/营业总收入
     */
    public Float getOpOfGr() {
        return opOfGr;
    }

    /**
     * 设置营业利润/营业总收入
     *
     * @param opOfGr 营业利润/营业总收入
     */
    public void setOpOfGr(Float opOfGr) {
        this.opOfGr = opOfGr;
    }

    /**
     * 获取息税前利润/营业总收入
     *
     * @return ebit_of_gr - 息税前利润/营业总收入
     */
    public Float getEbitOfGr() {
        return ebitOfGr;
    }

    /**
     * 设置息税前利润/营业总收入
     *
     * @param ebitOfGr 息税前利润/营业总收入
     */
    public void setEbitOfGr(Float ebitOfGr) {
        this.ebitOfGr = ebitOfGr;
    }

    /**
     * 获取净资产收益率
     *
     * @return roe - 净资产收益率
     */
    public Float getRoe() {
        return roe;
    }

    /**
     * 设置净资产收益率
     *
     * @param roe 净资产收益率
     */
    public void setRoe(Float roe) {
        this.roe = roe;
    }

    /**
     * 获取加权平均净资产收益率
     *
     * @return roe_waa - 加权平均净资产收益率
     */
    public Float getRoeWaa() {
        return roeWaa;
    }

    /**
     * 设置加权平均净资产收益率
     *
     * @param roeWaa 加权平均净资产收益率
     */
    public void setRoeWaa(Float roeWaa) {
        this.roeWaa = roeWaa;
    }

    /**
     * 获取净资产收益率(扣除非经常损益)
     *
     * @return roe_dt - 净资产收益率(扣除非经常损益)
     */
    public Float getRoeDt() {
        return roeDt;
    }

    /**
     * 设置净资产收益率(扣除非经常损益)
     *
     * @param roeDt 净资产收益率(扣除非经常损益)
     */
    public void setRoeDt(Float roeDt) {
        this.roeDt = roeDt;
    }

    /**
     * 获取总资产报酬率
     *
     * @return roa - 总资产报酬率
     */
    public Float getRoa() {
        return roa;
    }

    /**
     * 设置总资产报酬率
     *
     * @param roa 总资产报酬率
     */
    public void setRoa(Float roa) {
        this.roa = roa;
    }

    /**
     * 获取总资产净利润
     *
     * @return npta - 总资产净利润
     */
    public Float getNpta() {
        return npta;
    }

    /**
     * 设置总资产净利润
     *
     * @param npta 总资产净利润
     */
    public void setNpta(Float npta) {
        this.npta = npta;
    }

    /**
     * 获取投入资本回报率
     *
     * @return roic - 投入资本回报率
     */
    public Float getRoic() {
        return roic;
    }

    /**
     * 设置投入资本回报率
     *
     * @param roic 投入资本回报率
     */
    public void setRoic(Float roic) {
        this.roic = roic;
    }

    /**
     * 获取年化净资产收益率
     *
     * @return roe_yearly - 年化净资产收益率
     */
    public Float getRoeYearly() {
        return roeYearly;
    }

    /**
     * 设置年化净资产收益率
     *
     * @param roeYearly 年化净资产收益率
     */
    public void setRoeYearly(Float roeYearly) {
        this.roeYearly = roeYearly;
    }

    /**
     * 获取年化总资产报酬率
     *
     * @return roa2_yearly - 年化总资产报酬率
     */
    public Float getRoa2Yearly() {
        return roa2Yearly;
    }

    /**
     * 设置年化总资产报酬率
     *
     * @param roa2Yearly 年化总资产报酬率
     */
    public void setRoa2Yearly(Float roa2Yearly) {
        this.roa2Yearly = roa2Yearly;
    }

    /**
     * 获取平均净资产收益率(增发条件)
     *
     * @return roe_avg - 平均净资产收益率(增发条件)
     */
    public Float getRoeAvg() {
        return roeAvg;
    }

    /**
     * 设置平均净资产收益率(增发条件)
     *
     * @param roeAvg 平均净资产收益率(增发条件)
     */
    public void setRoeAvg(Float roeAvg) {
        this.roeAvg = roeAvg;
    }

    /**
     * 获取经营活动净收益/利润总额
     *
     * @return opincome_of_ebt - 经营活动净收益/利润总额
     */
    public Float getOpincomeOfEbt() {
        return opincomeOfEbt;
    }

    /**
     * 设置经营活动净收益/利润总额
     *
     * @param opincomeOfEbt 经营活动净收益/利润总额
     */
    public void setOpincomeOfEbt(Float opincomeOfEbt) {
        this.opincomeOfEbt = opincomeOfEbt;
    }

    /**
     * 获取价值变动净收益/利润总额
     *
     * @return investincome_of_ebt - 价值变动净收益/利润总额
     */
    public Float getInvestincomeOfEbt() {
        return investincomeOfEbt;
    }

    /**
     * 设置价值变动净收益/利润总额
     *
     * @param investincomeOfEbt 价值变动净收益/利润总额
     */
    public void setInvestincomeOfEbt(Float investincomeOfEbt) {
        this.investincomeOfEbt = investincomeOfEbt;
    }

    /**
     * 获取营业外收支净额/利润总额
     *
     * @return n_op_profit_of_ebt - 营业外收支净额/利润总额
     */
    public Float getnOpProfitOfEbt() {
        return nOpProfitOfEbt;
    }

    /**
     * 设置营业外收支净额/利润总额
     *
     * @param nOpProfitOfEbt 营业外收支净额/利润总额
     */
    public void setnOpProfitOfEbt(Float nOpProfitOfEbt) {
        this.nOpProfitOfEbt = nOpProfitOfEbt;
    }

    /**
     * 获取所得税/利润总额
     *
     * @return tax_to_ebt - 所得税/利润总额
     */
    public Float getTaxToEbt() {
        return taxToEbt;
    }

    /**
     * 设置所得税/利润总额
     *
     * @param taxToEbt 所得税/利润总额
     */
    public void setTaxToEbt(Float taxToEbt) {
        this.taxToEbt = taxToEbt;
    }

    /**
     * 获取扣除非经常损益后的净利润/净利润
     *
     * @return dtprofit_to_profit - 扣除非经常损益后的净利润/净利润
     */
    public Float getDtprofitToProfit() {
        return dtprofitToProfit;
    }

    /**
     * 设置扣除非经常损益后的净利润/净利润
     *
     * @param dtprofitToProfit 扣除非经常损益后的净利润/净利润
     */
    public void setDtprofitToProfit(Float dtprofitToProfit) {
        this.dtprofitToProfit = dtprofitToProfit;
    }

    /**
     * 获取销售商品提供劳务收到的现金/营业收入
     *
     * @return salescash_to_or - 销售商品提供劳务收到的现金/营业收入
     */
    public Float getSalescashToOr() {
        return salescashToOr;
    }

    /**
     * 设置销售商品提供劳务收到的现金/营业收入
     *
     * @param salescashToOr 销售商品提供劳务收到的现金/营业收入
     */
    public void setSalescashToOr(Float salescashToOr) {
        this.salescashToOr = salescashToOr;
    }

    /**
     * 获取经营活动产生的现金流量净额/营业收入
     *
     * @return ocf_to_or - 经营活动产生的现金流量净额/营业收入
     */
    public Float getOcfToOr() {
        return ocfToOr;
    }

    /**
     * 设置经营活动产生的现金流量净额/营业收入
     *
     * @param ocfToOr 经营活动产生的现金流量净额/营业收入
     */
    public void setOcfToOr(Float ocfToOr) {
        this.ocfToOr = ocfToOr;
    }

    /**
     * 获取经营活动产生的现金流量净额/经营活动净收益
     *
     * @return ocf_to_opincome - 经营活动产生的现金流量净额/经营活动净收益
     */
    public Float getOcfToOpincome() {
        return ocfToOpincome;
    }

    /**
     * 设置经营活动产生的现金流量净额/经营活动净收益
     *
     * @param ocfToOpincome 经营活动产生的现金流量净额/经营活动净收益
     */
    public void setOcfToOpincome(Float ocfToOpincome) {
        this.ocfToOpincome = ocfToOpincome;
    }

    /**
     * 获取资本支出/折旧和摊销
     *
     * @return capitalized_to_da - 资本支出/折旧和摊销
     */
    public Float getCapitalizedToDa() {
        return capitalizedToDa;
    }

    /**
     * 设置资本支出/折旧和摊销
     *
     * @param capitalizedToDa 资本支出/折旧和摊销
     */
    public void setCapitalizedToDa(Float capitalizedToDa) {
        this.capitalizedToDa = capitalizedToDa;
    }

    /**
     * 获取资产负债率
     *
     * @return debt_to_assets - 资产负债率
     */
    public Float getDebtToAssets() {
        return debtToAssets;
    }

    /**
     * 设置资产负债率
     *
     * @param debtToAssets 资产负债率
     */
    public void setDebtToAssets(Float debtToAssets) {
        this.debtToAssets = debtToAssets;
    }

    /**
     * 获取权益乘数
     *
     * @return assets_to_eqt - 权益乘数
     */
    public Float getAssetsToEqt() {
        return assetsToEqt;
    }

    /**
     * 设置权益乘数
     *
     * @param assetsToEqt 权益乘数
     */
    public void setAssetsToEqt(Float assetsToEqt) {
        this.assetsToEqt = assetsToEqt;
    }

    /**
     * 获取权益乘数(杜邦分析)
     *
     * @return dp_assets_to_eqt - 权益乘数(杜邦分析)
     */
    public Float getDpAssetsToEqt() {
        return dpAssetsToEqt;
    }

    /**
     * 设置权益乘数(杜邦分析)
     *
     * @param dpAssetsToEqt 权益乘数(杜邦分析)
     */
    public void setDpAssetsToEqt(Float dpAssetsToEqt) {
        this.dpAssetsToEqt = dpAssetsToEqt;
    }

    /**
     * 获取流动资产/总资产
     *
     * @return ca_to_assets - 流动资产/总资产
     */
    public Float getCaToAssets() {
        return caToAssets;
    }

    /**
     * 设置流动资产/总资产
     *
     * @param caToAssets 流动资产/总资产
     */
    public void setCaToAssets(Float caToAssets) {
        this.caToAssets = caToAssets;
    }

    /**
     * 获取非流动资产/总资产
     *
     * @return nca_to_assets - 非流动资产/总资产
     */
    public Float getNcaToAssets() {
        return ncaToAssets;
    }

    /**
     * 设置非流动资产/总资产
     *
     * @param ncaToAssets 非流动资产/总资产
     */
    public void setNcaToAssets(Float ncaToAssets) {
        this.ncaToAssets = ncaToAssets;
    }

    /**
     * 获取有形资产/总资产
     *
     * @return tbassets_to_totalassets - 有形资产/总资产
     */
    public Float getTbassetsToTotalassets() {
        return tbassetsToTotalassets;
    }

    /**
     * 设置有形资产/总资产
     *
     * @param tbassetsToTotalassets 有形资产/总资产
     */
    public void setTbassetsToTotalassets(Float tbassetsToTotalassets) {
        this.tbassetsToTotalassets = tbassetsToTotalassets;
    }

    /**
     * 获取带息债务/全部投入资本
     *
     * @return int_to_talcap - 带息债务/全部投入资本
     */
    public Float getIntToTalcap() {
        return intToTalcap;
    }

    /**
     * 设置带息债务/全部投入资本
     *
     * @param intToTalcap 带息债务/全部投入资本
     */
    public void setIntToTalcap(Float intToTalcap) {
        this.intToTalcap = intToTalcap;
    }

    /**
     * 获取归属于母公司的股东权益/全部投入资本
     *
     * @return eqt_to_talcapital - 归属于母公司的股东权益/全部投入资本
     */
    public Float getEqtToTalcapital() {
        return eqtToTalcapital;
    }

    /**
     * 设置归属于母公司的股东权益/全部投入资本
     *
     * @param eqtToTalcapital 归属于母公司的股东权益/全部投入资本
     */
    public void setEqtToTalcapital(Float eqtToTalcapital) {
        this.eqtToTalcapital = eqtToTalcapital;
    }

    /**
     * 获取流动负债/负债合计
     *
     * @return currentdebt_to_debt - 流动负债/负债合计
     */
    public Float getCurrentdebtToDebt() {
        return currentdebtToDebt;
    }

    /**
     * 设置流动负债/负债合计
     *
     * @param currentdebtToDebt 流动负债/负债合计
     */
    public void setCurrentdebtToDebt(Float currentdebtToDebt) {
        this.currentdebtToDebt = currentdebtToDebt;
    }

    /**
     * 获取非流动负债/负债合计
     *
     * @return longdeb_to_debt - 非流动负债/负债合计
     */
    public Float getLongdebToDebt() {
        return longdebToDebt;
    }

    /**
     * 设置非流动负债/负债合计
     *
     * @param longdebToDebt 非流动负债/负债合计
     */
    public void setLongdebToDebt(Float longdebToDebt) {
        this.longdebToDebt = longdebToDebt;
    }

    /**
     * 获取经营活动产生的现金流量净额/流动负债
     *
     * @return ocf_to_shortdebt - 经营活动产生的现金流量净额/流动负债
     */
    public Float getOcfToShortdebt() {
        return ocfToShortdebt;
    }

    /**
     * 设置经营活动产生的现金流量净额/流动负债
     *
     * @param ocfToShortdebt 经营活动产生的现金流量净额/流动负债
     */
    public void setOcfToShortdebt(Float ocfToShortdebt) {
        this.ocfToShortdebt = ocfToShortdebt;
    }

    /**
     * 获取产权比率
     *
     * @return debt_to_eqt - 产权比率
     */
    public Float getDebtToEqt() {
        return debtToEqt;
    }

    /**
     * 设置产权比率
     *
     * @param debtToEqt 产权比率
     */
    public void setDebtToEqt(Float debtToEqt) {
        this.debtToEqt = debtToEqt;
    }

    /**
     * 获取归属于母公司的股东权益/负债合计
     *
     * @return eqt_to_debt - 归属于母公司的股东权益/负债合计
     */
    public Float getEqtToDebt() {
        return eqtToDebt;
    }

    /**
     * 设置归属于母公司的股东权益/负债合计
     *
     * @param eqtToDebt 归属于母公司的股东权益/负债合计
     */
    public void setEqtToDebt(Float eqtToDebt) {
        this.eqtToDebt = eqtToDebt;
    }

    /**
     * 获取归属于母公司的股东权益/带息债务
     *
     * @return eqt_to_interestdebt - 归属于母公司的股东权益/带息债务
     */
    public Float getEqtToInterestdebt() {
        return eqtToInterestdebt;
    }

    /**
     * 设置归属于母公司的股东权益/带息债务
     *
     * @param eqtToInterestdebt 归属于母公司的股东权益/带息债务
     */
    public void setEqtToInterestdebt(Float eqtToInterestdebt) {
        this.eqtToInterestdebt = eqtToInterestdebt;
    }

    /**
     * 获取有形资产/负债合计
     *
     * @return tangibleasset_to_debt - 有形资产/负债合计
     */
    public Float getTangibleassetToDebt() {
        return tangibleassetToDebt;
    }

    /**
     * 设置有形资产/负债合计
     *
     * @param tangibleassetToDebt 有形资产/负债合计
     */
    public void setTangibleassetToDebt(Float tangibleassetToDebt) {
        this.tangibleassetToDebt = tangibleassetToDebt;
    }

    /**
     * 获取有形资产/带息债务
     *
     * @return tangasset_to_intdebt - 有形资产/带息债务
     */
    public Float getTangassetToIntdebt() {
        return tangassetToIntdebt;
    }

    /**
     * 设置有形资产/带息债务
     *
     * @param tangassetToIntdebt 有形资产/带息债务
     */
    public void setTangassetToIntdebt(Float tangassetToIntdebt) {
        this.tangassetToIntdebt = tangassetToIntdebt;
    }

    /**
     * 获取有形资产/净债务
     *
     * @return tangibleasset_to_netdebt - 有形资产/净债务
     */
    public Float getTangibleassetToNetdebt() {
        return tangibleassetToNetdebt;
    }

    /**
     * 设置有形资产/净债务
     *
     * @param tangibleassetToNetdebt 有形资产/净债务
     */
    public void setTangibleassetToNetdebt(Float tangibleassetToNetdebt) {
        this.tangibleassetToNetdebt = tangibleassetToNetdebt;
    }

    /**
     * 获取经营活动产生的现金流量净额/负债合计
     *
     * @return ocf_to_debt - 经营活动产生的现金流量净额/负债合计
     */
    public Float getOcfToDebt() {
        return ocfToDebt;
    }

    /**
     * 设置经营活动产生的现金流量净额/负债合计
     *
     * @param ocfToDebt 经营活动产生的现金流量净额/负债合计
     */
    public void setOcfToDebt(Float ocfToDebt) {
        this.ocfToDebt = ocfToDebt;
    }

    /**
     * 获取经营活动产生的现金流量净额/带息债务
     *
     * @return ocf_to_interestdebt - 经营活动产生的现金流量净额/带息债务
     */
    public Float getOcfToInterestdebt() {
        return ocfToInterestdebt;
    }

    /**
     * 设置经营活动产生的现金流量净额/带息债务
     *
     * @param ocfToInterestdebt 经营活动产生的现金流量净额/带息债务
     */
    public void setOcfToInterestdebt(Float ocfToInterestdebt) {
        this.ocfToInterestdebt = ocfToInterestdebt;
    }

    /**
     * 获取经营活动产生的现金流量净额/净债务
     *
     * @return ocf_to_netdebt - 经营活动产生的现金流量净额/净债务
     */
    public Float getOcfToNetdebt() {
        return ocfToNetdebt;
    }

    /**
     * 设置经营活动产生的现金流量净额/净债务
     *
     * @param ocfToNetdebt 经营活动产生的现金流量净额/净债务
     */
    public void setOcfToNetdebt(Float ocfToNetdebt) {
        this.ocfToNetdebt = ocfToNetdebt;
    }

    /**
     * 获取已获利息倍数(EBIT/利息费用)
     *
     * @return ebit_to_interest - 已获利息倍数(EBIT/利息费用)
     */
    public Float getEbitToInterest() {
        return ebitToInterest;
    }

    /**
     * 设置已获利息倍数(EBIT/利息费用)
     *
     * @param ebitToInterest 已获利息倍数(EBIT/利息费用)
     */
    public void setEbitToInterest(Float ebitToInterest) {
        this.ebitToInterest = ebitToInterest;
    }

    /**
     * 获取长期债务与营运资金比率
     *
     * @return longdebt_to_workingcapital - 长期债务与营运资金比率
     */
    public Float getLongdebtToWorkingcapital() {
        return longdebtToWorkingcapital;
    }

    /**
     * 设置长期债务与营运资金比率
     *
     * @param longdebtToWorkingcapital 长期债务与营运资金比率
     */
    public void setLongdebtToWorkingcapital(Float longdebtToWorkingcapital) {
        this.longdebtToWorkingcapital = longdebtToWorkingcapital;
    }

    /**
     * 获取息税折旧摊销前利润/负债合计
     *
     * @return ebitda_to_debt - 息税折旧摊销前利润/负债合计
     */
    public Float getEbitdaToDebt() {
        return ebitdaToDebt;
    }

    /**
     * 设置息税折旧摊销前利润/负债合计
     *
     * @param ebitdaToDebt 息税折旧摊销前利润/负债合计
     */
    public void setEbitdaToDebt(Float ebitdaToDebt) {
        this.ebitdaToDebt = ebitdaToDebt;
    }

    /**
     * 获取营业周期
     *
     * @return turn_days - 营业周期
     */
    public Float getTurnDays() {
        return turnDays;
    }

    /**
     * 设置营业周期
     *
     * @param turnDays 营业周期
     */
    public void setTurnDays(Float turnDays) {
        this.turnDays = turnDays;
    }

    /**
     * 获取年化总资产净利率
     *
     * @return roa_yearly - 年化总资产净利率
     */
    public Float getRoaYearly() {
        return roaYearly;
    }

    /**
     * 设置年化总资产净利率
     *
     * @param roaYearly 年化总资产净利率
     */
    public void setRoaYearly(Float roaYearly) {
        this.roaYearly = roaYearly;
    }

    /**
     * 获取总资产净利率(杜邦分析)
     *
     * @return roa_dp - 总资产净利率(杜邦分析)
     */
    public Float getRoaDp() {
        return roaDp;
    }

    /**
     * 设置总资产净利率(杜邦分析)
     *
     * @param roaDp 总资产净利率(杜邦分析)
     */
    public void setRoaDp(Float roaDp) {
        this.roaDp = roaDp;
    }

    /**
     * 获取固定资产合计
     *
     * @return fixed_assets - 固定资产合计
     */
    public Float getFixedAssets() {
        return fixedAssets;
    }

    /**
     * 设置固定资产合计
     *
     * @param fixedAssets 固定资产合计
     */
    public void setFixedAssets(Float fixedAssets) {
        this.fixedAssets = fixedAssets;
    }

    /**
     * 获取扣除财务费用前营业利润
     *
     * @return profit_prefin_exp - 扣除财务费用前营业利润
     */
    public Float getProfitPrefinExp() {
        return profitPrefinExp;
    }

    /**
     * 设置扣除财务费用前营业利润
     *
     * @param profitPrefinExp 扣除财务费用前营业利润
     */
    public void setProfitPrefinExp(Float profitPrefinExp) {
        this.profitPrefinExp = profitPrefinExp;
    }

    /**
     * 获取非营业利润
     *
     * @return non_op_profit - 非营业利润
     */
    public Float getNonOpProfit() {
        return nonOpProfit;
    }

    /**
     * 设置非营业利润
     *
     * @param nonOpProfit 非营业利润
     */
    public void setNonOpProfit(Float nonOpProfit) {
        this.nonOpProfit = nonOpProfit;
    }

    /**
     * 获取营业利润／利润总额
     *
     * @return op_to_ebt - 营业利润／利润总额
     */
    public Float getOpToEbt() {
        return opToEbt;
    }

    /**
     * 设置营业利润／利润总额
     *
     * @param opToEbt 营业利润／利润总额
     */
    public void setOpToEbt(Float opToEbt) {
        this.opToEbt = opToEbt;
    }

    /**
     * 获取非营业利润／利润总额
     *
     * @return nop_to_ebt - 非营业利润／利润总额
     */
    public Float getNopToEbt() {
        return nopToEbt;
    }

    /**
     * 设置非营业利润／利润总额
     *
     * @param nopToEbt 非营业利润／利润总额
     */
    public void setNopToEbt(Float nopToEbt) {
        this.nopToEbt = nopToEbt;
    }

    /**
     * 获取经营活动产生的现金流量净额／营业利润
     *
     * @return ocf_to_profit - 经营活动产生的现金流量净额／营业利润
     */
    public Float getOcfToProfit() {
        return ocfToProfit;
    }

    /**
     * 设置经营活动产生的现金流量净额／营业利润
     *
     * @param ocfToProfit 经营活动产生的现金流量净额／营业利润
     */
    public void setOcfToProfit(Float ocfToProfit) {
        this.ocfToProfit = ocfToProfit;
    }

    /**
     * 获取货币资金／流动负债
     *
     * @return cash_to_liqdebt - 货币资金／流动负债
     */
    public Float getCashToLiqdebt() {
        return cashToLiqdebt;
    }

    /**
     * 设置货币资金／流动负债
     *
     * @param cashToLiqdebt 货币资金／流动负债
     */
    public void setCashToLiqdebt(Float cashToLiqdebt) {
        this.cashToLiqdebt = cashToLiqdebt;
    }

    /**
     * 获取货币资金／带息流动负债
     *
     * @return cash_to_liqdebt_withinterest - 货币资金／带息流动负债
     */
    public Float getCashToLiqdebtWithinterest() {
        return cashToLiqdebtWithinterest;
    }

    /**
     * 设置货币资金／带息流动负债
     *
     * @param cashToLiqdebtWithinterest 货币资金／带息流动负债
     */
    public void setCashToLiqdebtWithinterest(Float cashToLiqdebtWithinterest) {
        this.cashToLiqdebtWithinterest = cashToLiqdebtWithinterest;
    }

    /**
     * 获取营业利润／流动负债
     *
     * @return op_to_liqdebt - 营业利润／流动负债
     */
    public Float getOpToLiqdebt() {
        return opToLiqdebt;
    }

    /**
     * 设置营业利润／流动负债
     *
     * @param opToLiqdebt 营业利润／流动负债
     */
    public void setOpToLiqdebt(Float opToLiqdebt) {
        this.opToLiqdebt = opToLiqdebt;
    }

    /**
     * 获取营业利润／负债合计
     *
     * @return op_to_debt - 营业利润／负债合计
     */
    public Float getOpToDebt() {
        return opToDebt;
    }

    /**
     * 设置营业利润／负债合计
     *
     * @param opToDebt 营业利润／负债合计
     */
    public void setOpToDebt(Float opToDebt) {
        this.opToDebt = opToDebt;
    }

    /**
     * 获取年化投入资本回报率
     *
     * @return roic_yearly - 年化投入资本回报率
     */
    public Float getRoicYearly() {
        return roicYearly;
    }

    /**
     * 设置年化投入资本回报率
     *
     * @param roicYearly 年化投入资本回报率
     */
    public void setRoicYearly(Float roicYearly) {
        this.roicYearly = roicYearly;
    }

    /**
     * 获取固定资产合计周转率
     *
     * @return total_fa_trun - 固定资产合计周转率
     */
    public Float getTotalFaTrun() {
        return totalFaTrun;
    }

    /**
     * 设置固定资产合计周转率
     *
     * @param totalFaTrun 固定资产合计周转率
     */
    public void setTotalFaTrun(Float totalFaTrun) {
        this.totalFaTrun = totalFaTrun;
    }

    /**
     * 获取利润总额／营业收入
     *
     * @return profit_to_op - 利润总额／营业收入
     */
    public Float getProfitToOp() {
        return profitToOp;
    }

    /**
     * 设置利润总额／营业收入
     *
     * @param profitToOp 利润总额／营业收入
     */
    public void setProfitToOp(Float profitToOp) {
        this.profitToOp = profitToOp;
    }

    /**
     * 获取经营活动单季度净收益
     *
     * @return q_opincome - 经营活动单季度净收益
     */
    public Float getqOpincome() {
        return qOpincome;
    }

    /**
     * 设置经营活动单季度净收益
     *
     * @param qOpincome 经营活动单季度净收益
     */
    public void setqOpincome(Float qOpincome) {
        this.qOpincome = qOpincome;
    }

    /**
     * 获取价值变动单季度净收益
     *
     * @return q_investincome - 价值变动单季度净收益
     */
    public Float getqInvestincome() {
        return qInvestincome;
    }

    /**
     * 设置价值变动单季度净收益
     *
     * @param qInvestincome 价值变动单季度净收益
     */
    public void setqInvestincome(Float qInvestincome) {
        this.qInvestincome = qInvestincome;
    }

    /**
     * 获取扣除非经常损益后的单季度净利润
     *
     * @return q_dtprofit - 扣除非经常损益后的单季度净利润
     */
    public Float getqDtprofit() {
        return qDtprofit;
    }

    /**
     * 设置扣除非经常损益后的单季度净利润
     *
     * @param qDtprofit 扣除非经常损益后的单季度净利润
     */
    public void setqDtprofit(Float qDtprofit) {
        this.qDtprofit = qDtprofit;
    }

    /**
     * 获取每股收益(单季度)
     *
     * @return q_eps - 每股收益(单季度)
     */
    public Float getqEps() {
        return qEps;
    }

    /**
     * 设置每股收益(单季度)
     *
     * @param qEps 每股收益(单季度)
     */
    public void setqEps(Float qEps) {
        this.qEps = qEps;
    }

    /**
     * 获取销售净利率(单季度)
     *
     * @return q_netprofit_margin - 销售净利率(单季度)
     */
    public Float getqNetprofitMargin() {
        return qNetprofitMargin;
    }

    /**
     * 设置销售净利率(单季度)
     *
     * @param qNetprofitMargin 销售净利率(单季度)
     */
    public void setqNetprofitMargin(Float qNetprofitMargin) {
        this.qNetprofitMargin = qNetprofitMargin;
    }

    /**
     * 获取销售毛利率(单季度)
     *
     * @return q_gsprofit_margin - 销售毛利率(单季度)
     */
    public Float getqGsprofitMargin() {
        return qGsprofitMargin;
    }

    /**
     * 设置销售毛利率(单季度)
     *
     * @param qGsprofitMargin 销售毛利率(单季度)
     */
    public void setqGsprofitMargin(Float qGsprofitMargin) {
        this.qGsprofitMargin = qGsprofitMargin;
    }

    /**
     * 获取销售期间费用率(单季度)
     *
     * @return q_exp_to_sales - 销售期间费用率(单季度)
     */
    public Float getqExpToSales() {
        return qExpToSales;
    }

    /**
     * 设置销售期间费用率(单季度)
     *
     * @param qExpToSales 销售期间费用率(单季度)
     */
    public void setqExpToSales(Float qExpToSales) {
        this.qExpToSales = qExpToSales;
    }

    /**
     * 获取净利润／营业总收入(单季度)
     *
     * @return q_profit_to_gr - 净利润／营业总收入(单季度)
     */
    public Float getqProfitToGr() {
        return qProfitToGr;
    }

    /**
     * 设置净利润／营业总收入(单季度)
     *
     * @param qProfitToGr 净利润／营业总收入(单季度)
     */
    public void setqProfitToGr(Float qProfitToGr) {
        this.qProfitToGr = qProfitToGr;
    }

    /**
     * 获取销售费用／营业总收入 (单季度)
     *
     * @return q_saleexp_to_gr - 销售费用／营业总收入 (单季度)
     */
    public Float getqSaleexpToGr() {
        return qSaleexpToGr;
    }

    /**
     * 设置销售费用／营业总收入 (单季度)
     *
     * @param qSaleexpToGr 销售费用／营业总收入 (单季度)
     */
    public void setqSaleexpToGr(Float qSaleexpToGr) {
        this.qSaleexpToGr = qSaleexpToGr;
    }

    /**
     * 获取管理费用／营业总收入 (单季度)
     *
     * @return q_adminexp_to_gr - 管理费用／营业总收入 (单季度)
     */
    public Float getqAdminexpToGr() {
        return qAdminexpToGr;
    }

    /**
     * 设置管理费用／营业总收入 (单季度)
     *
     * @param qAdminexpToGr 管理费用／营业总收入 (单季度)
     */
    public void setqAdminexpToGr(Float qAdminexpToGr) {
        this.qAdminexpToGr = qAdminexpToGr;
    }

    /**
     * 获取财务费用／营业总收入 (单季度)
     *
     * @return q_finaexp_to_gr - 财务费用／营业总收入 (单季度)
     */
    public Float getqFinaexpToGr() {
        return qFinaexpToGr;
    }

    /**
     * 设置财务费用／营业总收入 (单季度)
     *
     * @param qFinaexpToGr 财务费用／营业总收入 (单季度)
     */
    public void setqFinaexpToGr(Float qFinaexpToGr) {
        this.qFinaexpToGr = qFinaexpToGr;
    }

    /**
     * 获取资产减值损失／营业总收入(单季度)
     *
     * @return q_impair_to_gr_ttm - 资产减值损失／营业总收入(单季度)
     */
    public Float getqImpairToGrTtm() {
        return qImpairToGrTtm;
    }

    /**
     * 设置资产减值损失／营业总收入(单季度)
     *
     * @param qImpairToGrTtm 资产减值损失／营业总收入(单季度)
     */
    public void setqImpairToGrTtm(Float qImpairToGrTtm) {
        this.qImpairToGrTtm = qImpairToGrTtm;
    }

    /**
     * 获取营业总成本／营业总收入 (单季度)
     *
     * @return q_gc_to_gr - 营业总成本／营业总收入 (单季度)
     */
    public Float getqGcToGr() {
        return qGcToGr;
    }

    /**
     * 设置营业总成本／营业总收入 (单季度)
     *
     * @param qGcToGr 营业总成本／营业总收入 (单季度)
     */
    public void setqGcToGr(Float qGcToGr) {
        this.qGcToGr = qGcToGr;
    }

    /**
     * 获取营业利润／营业总收入(单季度)
     *
     * @return q_op_to_gr - 营业利润／营业总收入(单季度)
     */
    public Float getqOpToGr() {
        return qOpToGr;
    }

    /**
     * 设置营业利润／营业总收入(单季度)
     *
     * @param qOpToGr 营业利润／营业总收入(单季度)
     */
    public void setqOpToGr(Float qOpToGr) {
        this.qOpToGr = qOpToGr;
    }

    /**
     * 获取净资产收益率(单季度)
     *
     * @return q_roe - 净资产收益率(单季度)
     */
    public Float getqRoe() {
        return qRoe;
    }

    /**
     * 设置净资产收益率(单季度)
     *
     * @param qRoe 净资产收益率(单季度)
     */
    public void setqRoe(Float qRoe) {
        this.qRoe = qRoe;
    }

    /**
     * 获取净资产单季度收益率(扣除非经常损益)
     *
     * @return q_dt_roe - 净资产单季度收益率(扣除非经常损益)
     */
    public Float getqDtRoe() {
        return qDtRoe;
    }

    /**
     * 设置净资产单季度收益率(扣除非经常损益)
     *
     * @param qDtRoe 净资产单季度收益率(扣除非经常损益)
     */
    public void setqDtRoe(Float qDtRoe) {
        this.qDtRoe = qDtRoe;
    }

    /**
     * 获取总资产净利润(单季度)
     *
     * @return q_npta - 总资产净利润(单季度)
     */
    public Float getqNpta() {
        return qNpta;
    }

    /**
     * 设置总资产净利润(单季度)
     *
     * @param qNpta 总资产净利润(单季度)
     */
    public void setqNpta(Float qNpta) {
        this.qNpta = qNpta;
    }

    /**
     * 获取经营活动净收益／利润总额(单季度)
     *
     * @return q_opincome_to_ebt - 经营活动净收益／利润总额(单季度)
     */
    public Float getqOpincomeToEbt() {
        return qOpincomeToEbt;
    }

    /**
     * 设置经营活动净收益／利润总额(单季度)
     *
     * @param qOpincomeToEbt 经营活动净收益／利润总额(单季度)
     */
    public void setqOpincomeToEbt(Float qOpincomeToEbt) {
        this.qOpincomeToEbt = qOpincomeToEbt;
    }

    /**
     * 获取价值变动净收益／利润总额(单季度)
     *
     * @return q_investincome_to_ebt - 价值变动净收益／利润总额(单季度)
     */
    public Float getqInvestincomeToEbt() {
        return qInvestincomeToEbt;
    }

    /**
     * 设置价值变动净收益／利润总额(单季度)
     *
     * @param qInvestincomeToEbt 价值变动净收益／利润总额(单季度)
     */
    public void setqInvestincomeToEbt(Float qInvestincomeToEbt) {
        this.qInvestincomeToEbt = qInvestincomeToEbt;
    }

    /**
     * 获取扣除非经常损益后的净利润／净利润(单季度)
     *
     * @return q_dtprofit_to_profit - 扣除非经常损益后的净利润／净利润(单季度)
     */
    public Float getqDtprofitToProfit() {
        return qDtprofitToProfit;
    }

    /**
     * 设置扣除非经常损益后的净利润／净利润(单季度)
     *
     * @param qDtprofitToProfit 扣除非经常损益后的净利润／净利润(单季度)
     */
    public void setqDtprofitToProfit(Float qDtprofitToProfit) {
        this.qDtprofitToProfit = qDtprofitToProfit;
    }

    /**
     * 获取销售商品提供劳务收到的现金／营业收入(单季度)
     *
     * @return q_salescash_to_or - 销售商品提供劳务收到的现金／营业收入(单季度)
     */
    public Float getqSalescashToOr() {
        return qSalescashToOr;
    }

    /**
     * 设置销售商品提供劳务收到的现金／营业收入(单季度)
     *
     * @param qSalescashToOr 销售商品提供劳务收到的现金／营业收入(单季度)
     */
    public void setqSalescashToOr(Float qSalescashToOr) {
        this.qSalescashToOr = qSalescashToOr;
    }

    /**
     * 获取经营活动产生的现金流量净额／营业收入(单季度)
     *
     * @return q_ocf_to_sales - 经营活动产生的现金流量净额／营业收入(单季度)
     */
    public Float getqOcfToSales() {
        return qOcfToSales;
    }

    /**
     * 设置经营活动产生的现金流量净额／营业收入(单季度)
     *
     * @param qOcfToSales 经营活动产生的现金流量净额／营业收入(单季度)
     */
    public void setqOcfToSales(Float qOcfToSales) {
        this.qOcfToSales = qOcfToSales;
    }

    /**
     * 获取经营活动产生的现金流量净额／经营活动净收益(单季度)
     *
     * @return q_ocf_to_or - 经营活动产生的现金流量净额／经营活动净收益(单季度)
     */
    public Float getqOcfToOr() {
        return qOcfToOr;
    }

    /**
     * 设置经营活动产生的现金流量净额／经营活动净收益(单季度)
     *
     * @param qOcfToOr 经营活动产生的现金流量净额／经营活动净收益(单季度)
     */
    public void setqOcfToOr(Float qOcfToOr) {
        this.qOcfToOr = qOcfToOr;
    }

    /**
     * 获取基本每股收益同比增长率(%)
     *
     * @return basic_eps_yoy - 基本每股收益同比增长率(%)
     */
    public Float getBasicEpsYoy() {
        return basicEpsYoy;
    }

    /**
     * 设置基本每股收益同比增长率(%)
     *
     * @param basicEpsYoy 基本每股收益同比增长率(%)
     */
    public void setBasicEpsYoy(Float basicEpsYoy) {
        this.basicEpsYoy = basicEpsYoy;
    }

    /**
     * 获取稀释每股收益同比增长率(%)
     *
     * @return dt_eps_yoy - 稀释每股收益同比增长率(%)
     */
    public Float getDtEpsYoy() {
        return dtEpsYoy;
    }

    /**
     * 设置稀释每股收益同比增长率(%)
     *
     * @param dtEpsYoy 稀释每股收益同比增长率(%)
     */
    public void setDtEpsYoy(Float dtEpsYoy) {
        this.dtEpsYoy = dtEpsYoy;
    }

    /**
     * 获取每股经营活动产生的现金流量净额同比增长率(%)
     *
     * @return cfps_yoy - 每股经营活动产生的现金流量净额同比增长率(%)
     */
    public Float getCfpsYoy() {
        return cfpsYoy;
    }

    /**
     * 设置每股经营活动产生的现金流量净额同比增长率(%)
     *
     * @param cfpsYoy 每股经营活动产生的现金流量净额同比增长率(%)
     */
    public void setCfpsYoy(Float cfpsYoy) {
        this.cfpsYoy = cfpsYoy;
    }

    /**
     * 获取营业利润同比增长率(%)
     *
     * @return op_yoy - 营业利润同比增长率(%)
     */
    public Float getOpYoy() {
        return opYoy;
    }

    /**
     * 设置营业利润同比增长率(%)
     *
     * @param opYoy 营业利润同比增长率(%)
     */
    public void setOpYoy(Float opYoy) {
        this.opYoy = opYoy;
    }

    /**
     * 获取利润总额同比增长率(%)
     *
     * @return ebt_yoy - 利润总额同比增长率(%)
     */
    public Float getEbtYoy() {
        return ebtYoy;
    }

    /**
     * 设置利润总额同比增长率(%)
     *
     * @param ebtYoy 利润总额同比增长率(%)
     */
    public void setEbtYoy(Float ebtYoy) {
        this.ebtYoy = ebtYoy;
    }

    /**
     * 获取归属母公司股东的净利润同比增长率(%)
     *
     * @return netprofit_yoy - 归属母公司股东的净利润同比增长率(%)
     */
    public Float getNetprofitYoy() {
        return netprofitYoy;
    }

    /**
     * 设置归属母公司股东的净利润同比增长率(%)
     *
     * @param netprofitYoy 归属母公司股东的净利润同比增长率(%)
     */
    public void setNetprofitYoy(Float netprofitYoy) {
        this.netprofitYoy = netprofitYoy;
    }

    /**
     * 获取归属母公司股东的净利润-扣除非经常损益同比增长率(%)
     *
     * @return dt_netprofit_yoy - 归属母公司股东的净利润-扣除非经常损益同比增长率(%)
     */
    public Float getDtNetprofitYoy() {
        return dtNetprofitYoy;
    }

    /**
     * 设置归属母公司股东的净利润-扣除非经常损益同比增长率(%)
     *
     * @param dtNetprofitYoy 归属母公司股东的净利润-扣除非经常损益同比增长率(%)
     */
    public void setDtNetprofitYoy(Float dtNetprofitYoy) {
        this.dtNetprofitYoy = dtNetprofitYoy;
    }

    /**
     * 获取经营活动产生的现金流量净额同比增长率(%)
     *
     * @return ocf_yoy - 经营活动产生的现金流量净额同比增长率(%)
     */
    public Float getOcfYoy() {
        return ocfYoy;
    }

    /**
     * 设置经营活动产生的现金流量净额同比增长率(%)
     *
     * @param ocfYoy 经营活动产生的现金流量净额同比增长率(%)
     */
    public void setOcfYoy(Float ocfYoy) {
        this.ocfYoy = ocfYoy;
    }

    /**
     * 获取净资产收益率(摊薄)同比增长率(%)
     *
     * @return roe_yoy - 净资产收益率(摊薄)同比增长率(%)
     */
    public Float getRoeYoy() {
        return roeYoy;
    }

    /**
     * 设置净资产收益率(摊薄)同比增长率(%)
     *
     * @param roeYoy 净资产收益率(摊薄)同比增长率(%)
     */
    public void setRoeYoy(Float roeYoy) {
        this.roeYoy = roeYoy;
    }

    /**
     * 获取每股净资产相对年初增长率(%)
     *
     * @return bps_yoy - 每股净资产相对年初增长率(%)
     */
    public Float getBpsYoy() {
        return bpsYoy;
    }

    /**
     * 设置每股净资产相对年初增长率(%)
     *
     * @param bpsYoy 每股净资产相对年初增长率(%)
     */
    public void setBpsYoy(Float bpsYoy) {
        this.bpsYoy = bpsYoy;
    }

    /**
     * 获取资产总计相对年初增长率(%)
     *
     * @return assets_yoy - 资产总计相对年初增长率(%)
     */
    public Float getAssetsYoy() {
        return assetsYoy;
    }

    /**
     * 设置资产总计相对年初增长率(%)
     *
     * @param assetsYoy 资产总计相对年初增长率(%)
     */
    public void setAssetsYoy(Float assetsYoy) {
        this.assetsYoy = assetsYoy;
    }

    /**
     * 获取归属母公司的股东权益相对年初增长率(%)
     *
     * @return eqt_yoy - 归属母公司的股东权益相对年初增长率(%)
     */
    public Float getEqtYoy() {
        return eqtYoy;
    }

    /**
     * 设置归属母公司的股东权益相对年初增长率(%)
     *
     * @param eqtYoy 归属母公司的股东权益相对年初增长率(%)
     */
    public void setEqtYoy(Float eqtYoy) {
        this.eqtYoy = eqtYoy;
    }

    /**
     * 获取营业总收入同比增长率(%)
     *
     * @return tr_yoy - 营业总收入同比增长率(%)
     */
    public Float getTrYoy() {
        return trYoy;
    }

    /**
     * 设置营业总收入同比增长率(%)
     *
     * @param trYoy 营业总收入同比增长率(%)
     */
    public void setTrYoy(Float trYoy) {
        this.trYoy = trYoy;
    }

    /**
     * 获取营业收入同比增长率(%)
     *
     * @return or_yoy - 营业收入同比增长率(%)
     */
    public Float getOrYoy() {
        return orYoy;
    }

    /**
     * 设置营业收入同比增长率(%)
     *
     * @param orYoy 营业收入同比增长率(%)
     */
    public void setOrYoy(Float orYoy) {
        this.orYoy = orYoy;
    }

    /**
     * 获取营业总收入同比增长率(%)(单季度)
     *
     * @return q_gr_yoy - 营业总收入同比增长率(%)(单季度)
     */
    public Float getqGrYoy() {
        return qGrYoy;
    }

    /**
     * 设置营业总收入同比增长率(%)(单季度)
     *
     * @param qGrYoy 营业总收入同比增长率(%)(单季度)
     */
    public void setqGrYoy(Float qGrYoy) {
        this.qGrYoy = qGrYoy;
    }

    /**
     * 获取营业总收入环比增长率(%)(单季度)
     *
     * @return q_gr_qoq - 营业总收入环比增长率(%)(单季度)
     */
    public Float getqGrQoq() {
        return qGrQoq;
    }

    /**
     * 设置营业总收入环比增长率(%)(单季度)
     *
     * @param qGrQoq 营业总收入环比增长率(%)(单季度)
     */
    public void setqGrQoq(Float qGrQoq) {
        this.qGrQoq = qGrQoq;
    }

    /**
     * 获取营业收入同比增长率(%)(单季度)
     *
     * @return q_sales_yoy - 营业收入同比增长率(%)(单季度)
     */
    public Float getqSalesYoy() {
        return qSalesYoy;
    }

    /**
     * 设置营业收入同比增长率(%)(单季度)
     *
     * @param qSalesYoy 营业收入同比增长率(%)(单季度)
     */
    public void setqSalesYoy(Float qSalesYoy) {
        this.qSalesYoy = qSalesYoy;
    }

    /**
     * 获取营业收入环比增长率(%)(单季度)
     *
     * @return q_sales_qoq - 营业收入环比增长率(%)(单季度)
     */
    public Float getqSalesQoq() {
        return qSalesQoq;
    }

    /**
     * 设置营业收入环比增长率(%)(单季度)
     *
     * @param qSalesQoq 营业收入环比增长率(%)(单季度)
     */
    public void setqSalesQoq(Float qSalesQoq) {
        this.qSalesQoq = qSalesQoq;
    }

    /**
     * 获取营业利润同比增长率(%)(单季度)
     *
     * @return q_op_yoy - 营业利润同比增长率(%)(单季度)
     */
    public Float getqOpYoy() {
        return qOpYoy;
    }

    /**
     * 设置营业利润同比增长率(%)(单季度)
     *
     * @param qOpYoy 营业利润同比增长率(%)(单季度)
     */
    public void setqOpYoy(Float qOpYoy) {
        this.qOpYoy = qOpYoy;
    }

    /**
     * 获取营业利润环比增长率(%)(单季度)
     *
     * @return q_op_qoq - 营业利润环比增长率(%)(单季度)
     */
    public Float getqOpQoq() {
        return qOpQoq;
    }

    /**
     * 设置营业利润环比增长率(%)(单季度)
     *
     * @param qOpQoq 营业利润环比增长率(%)(单季度)
     */
    public void setqOpQoq(Float qOpQoq) {
        this.qOpQoq = qOpQoq;
    }

    /**
     * 获取净利润同比增长率(%)(单季度)
     *
     * @return q_profit_yoy - 净利润同比增长率(%)(单季度)
     */
    public Float getqProfitYoy() {
        return qProfitYoy;
    }

    /**
     * 设置净利润同比增长率(%)(单季度)
     *
     * @param qProfitYoy 净利润同比增长率(%)(单季度)
     */
    public void setqProfitYoy(Float qProfitYoy) {
        this.qProfitYoy = qProfitYoy;
    }

    /**
     * 获取净利润环比增长率(%)(单季度)
     *
     * @return q_profit_qoq - 净利润环比增长率(%)(单季度)
     */
    public Float getqProfitQoq() {
        return qProfitQoq;
    }

    /**
     * 设置净利润环比增长率(%)(单季度)
     *
     * @param qProfitQoq 净利润环比增长率(%)(单季度)
     */
    public void setqProfitQoq(Float qProfitQoq) {
        this.qProfitQoq = qProfitQoq;
    }

    /**
     * 获取归属母公司股东的净利润同比增长率(%)(单季度)
     *
     * @return q_netprofit_yoy - 归属母公司股东的净利润同比增长率(%)(单季度)
     */
    public Float getqNetprofitYoy() {
        return qNetprofitYoy;
    }

    /**
     * 设置归属母公司股东的净利润同比增长率(%)(单季度)
     *
     * @param qNetprofitYoy 归属母公司股东的净利润同比增长率(%)(单季度)
     */
    public void setqNetprofitYoy(Float qNetprofitYoy) {
        this.qNetprofitYoy = qNetprofitYoy;
    }

    /**
     * 获取归属母公司股东的净利润环比增长率(%)(单季度)
     *
     * @return q_netprofit_qoq - 归属母公司股东的净利润环比增长率(%)(单季度)
     */
    public Float getqNetprofitQoq() {
        return qNetprofitQoq;
    }

    /**
     * 设置归属母公司股东的净利润环比增长率(%)(单季度)
     *
     * @param qNetprofitQoq 归属母公司股东的净利润环比增长率(%)(单季度)
     */
    public void setqNetprofitQoq(Float qNetprofitQoq) {
        this.qNetprofitQoq = qNetprofitQoq;
    }

    /**
     * 获取净资产同比增长率
     *
     * @return equity_yoy - 净资产同比增长率
     */
    public Float getEquityYoy() {
        return equityYoy;
    }

    /**
     * 设置净资产同比增长率
     *
     * @param equityYoy 净资产同比增长率
     */
    public void setEquityYoy(Float equityYoy) {
        this.equityYoy = equityYoy;
    }

    /**
     * 获取研发费用
     *
     * @return rd_exp - 研发费用
     */
    public Float getRdExp() {
        return rdExp;
    }

    /**
     * 设置研发费用
     *
     * @param rdExp 研发费用
     */
    public void setRdExp(Float rdExp) {
        this.rdExp = rdExp;
    }

    /**
     * 获取更新标识
     *
     * @return update_flag - 更新标识
     */
    public String getUpdateFlag() {
        return updateFlag;
    }

    /**
     * 设置更新标识
     *
     * @param updateFlag 更新标识
     */
    public void setUpdateFlag(String updateFlag) {
        this.updateFlag = updateFlag;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(getClass().getSimpleName());
        sb.append(" [");
        sb.append("Hash = ").append(hashCode());
        sb.append(", tid=").append(tid);
        sb.append(", tsCode=").append(tsCode);
        sb.append(", annDate=").append(annDate);
        sb.append(", endDate=").append(endDate);
        sb.append(", eps=").append(eps);
        sb.append(", dtEps=").append(dtEps);
        sb.append(", totalRevenuePs=").append(totalRevenuePs);
        sb.append(", revenuePs=").append(revenuePs);
        sb.append(", capitalResePs=").append(capitalResePs);
        sb.append(", surplusResePs=").append(surplusResePs);
        sb.append(", undistProfitPs=").append(undistProfitPs);
        sb.append(", extraItem=").append(extraItem);
        sb.append(", profitDedt=").append(profitDedt);
        sb.append(", grossMargin=").append(grossMargin);
        sb.append(", currentRatio=").append(currentRatio);
        sb.append(", quickRatio=").append(quickRatio);
        sb.append(", cashRatio=").append(cashRatio);
        sb.append(", invturnDays=").append(invturnDays);
        sb.append(", arturnDays=").append(arturnDays);
        sb.append(", invTurn=").append(invTurn);
        sb.append(", arTurn=").append(arTurn);
        sb.append(", caTurn=").append(caTurn);
        sb.append(", faTurn=").append(faTurn);
        sb.append(", assetsTurn=").append(assetsTurn);
        sb.append(", opIncome=").append(opIncome);
        sb.append(", valuechangeIncome=").append(valuechangeIncome);
        sb.append(", interstIncome=").append(interstIncome);
        sb.append(", daa=").append(daa);
        sb.append(", ebit=").append(ebit);
        sb.append(", ebitda=").append(ebitda);
        sb.append(", fcff=").append(fcff);
        sb.append(", fcfe=").append(fcfe);
        sb.append(", currentExint=").append(currentExint);
        sb.append(", noncurrentExint=").append(noncurrentExint);
        sb.append(", interestdebt=").append(interestdebt);
        sb.append(", netdebt=").append(netdebt);
        sb.append(", tangibleAsset=").append(tangibleAsset);
        sb.append(", workingCapital=").append(workingCapital);
        sb.append(", networkingCapital=").append(networkingCapital);
        sb.append(", investCapital=").append(investCapital);
        sb.append(", retainedEarnings=").append(retainedEarnings);
        sb.append(", diluted2Eps=").append(diluted2Eps);
        sb.append(", bps=").append(bps);
        sb.append(", ocfps=").append(ocfps);
        sb.append(", retainedps=").append(retainedps);
        sb.append(", cfps=").append(cfps);
        sb.append(", ebitPs=").append(ebitPs);
        sb.append(", fcffPs=").append(fcffPs);
        sb.append(", fcfePs=").append(fcfePs);
        sb.append(", netprofitMargin=").append(netprofitMargin);
        sb.append(", grossprofitMargin=").append(grossprofitMargin);
        sb.append(", cogsOfSales=").append(cogsOfSales);
        sb.append(", expenseOfSales=").append(expenseOfSales);
        sb.append(", profitToGr=").append(profitToGr);
        sb.append(", saleexpToGr=").append(saleexpToGr);
        sb.append(", adminexpOfGr=").append(adminexpOfGr);
        sb.append(", finaexpOfGr=").append(finaexpOfGr);
        sb.append(", impaiTtm=").append(impaiTtm);
        sb.append(", gcOfGr=").append(gcOfGr);
        sb.append(", opOfGr=").append(opOfGr);
        sb.append(", ebitOfGr=").append(ebitOfGr);
        sb.append(", roe=").append(roe);
        sb.append(", roeWaa=").append(roeWaa);
        sb.append(", roeDt=").append(roeDt);
        sb.append(", roa=").append(roa);
        sb.append(", npta=").append(npta);
        sb.append(", roic=").append(roic);
        sb.append(", roeYearly=").append(roeYearly);
        sb.append(", roa2Yearly=").append(roa2Yearly);
        sb.append(", roeAvg=").append(roeAvg);
        sb.append(", opincomeOfEbt=").append(opincomeOfEbt);
        sb.append(", investincomeOfEbt=").append(investincomeOfEbt);
        sb.append(", nOpProfitOfEbt=").append(nOpProfitOfEbt);
        sb.append(", taxToEbt=").append(taxToEbt);
        sb.append(", dtprofitToProfit=").append(dtprofitToProfit);
        sb.append(", salescashToOr=").append(salescashToOr);
        sb.append(", ocfToOr=").append(ocfToOr);
        sb.append(", ocfToOpincome=").append(ocfToOpincome);
        sb.append(", capitalizedToDa=").append(capitalizedToDa);
        sb.append(", debtToAssets=").append(debtToAssets);
        sb.append(", assetsToEqt=").append(assetsToEqt);
        sb.append(", dpAssetsToEqt=").append(dpAssetsToEqt);
        sb.append(", caToAssets=").append(caToAssets);
        sb.append(", ncaToAssets=").append(ncaToAssets);
        sb.append(", tbassetsToTotalassets=").append(tbassetsToTotalassets);
        sb.append(", intToTalcap=").append(intToTalcap);
        sb.append(", eqtToTalcapital=").append(eqtToTalcapital);
        sb.append(", currentdebtToDebt=").append(currentdebtToDebt);
        sb.append(", longdebToDebt=").append(longdebToDebt);
        sb.append(", ocfToShortdebt=").append(ocfToShortdebt);
        sb.append(", debtToEqt=").append(debtToEqt);
        sb.append(", eqtToDebt=").append(eqtToDebt);
        sb.append(", eqtToInterestdebt=").append(eqtToInterestdebt);
        sb.append(", tangibleassetToDebt=").append(tangibleassetToDebt);
        sb.append(", tangassetToIntdebt=").append(tangassetToIntdebt);
        sb.append(", tangibleassetToNetdebt=").append(tangibleassetToNetdebt);
        sb.append(", ocfToDebt=").append(ocfToDebt);
        sb.append(", ocfToInterestdebt=").append(ocfToInterestdebt);
        sb.append(", ocfToNetdebt=").append(ocfToNetdebt);
        sb.append(", ebitToInterest=").append(ebitToInterest);
        sb.append(", longdebtToWorkingcapital=").append(longdebtToWorkingcapital);
        sb.append(", ebitdaToDebt=").append(ebitdaToDebt);
        sb.append(", turnDays=").append(turnDays);
        sb.append(", roaYearly=").append(roaYearly);
        sb.append(", roaDp=").append(roaDp);
        sb.append(", fixedAssets=").append(fixedAssets);
        sb.append(", profitPrefinExp=").append(profitPrefinExp);
        sb.append(", nonOpProfit=").append(nonOpProfit);
        sb.append(", opToEbt=").append(opToEbt);
        sb.append(", nopToEbt=").append(nopToEbt);
        sb.append(", ocfToProfit=").append(ocfToProfit);
        sb.append(", cashToLiqdebt=").append(cashToLiqdebt);
        sb.append(", cashToLiqdebtWithinterest=").append(cashToLiqdebtWithinterest);
        sb.append(", opToLiqdebt=").append(opToLiqdebt);
        sb.append(", opToDebt=").append(opToDebt);
        sb.append(", roicYearly=").append(roicYearly);
        sb.append(", totalFaTrun=").append(totalFaTrun);
        sb.append(", profitToOp=").append(profitToOp);
        sb.append(", qOpincome=").append(qOpincome);
        sb.append(", qInvestincome=").append(qInvestincome);
        sb.append(", qDtprofit=").append(qDtprofit);
        sb.append(", qEps=").append(qEps);
        sb.append(", qNetprofitMargin=").append(qNetprofitMargin);
        sb.append(", qGsprofitMargin=").append(qGsprofitMargin);
        sb.append(", qExpToSales=").append(qExpToSales);
        sb.append(", qProfitToGr=").append(qProfitToGr);
        sb.append(", qSaleexpToGr=").append(qSaleexpToGr);
        sb.append(", qAdminexpToGr=").append(qAdminexpToGr);
        sb.append(", qFinaexpToGr=").append(qFinaexpToGr);
        sb.append(", qImpairToGrTtm=").append(qImpairToGrTtm);
        sb.append(", qGcToGr=").append(qGcToGr);
        sb.append(", qOpToGr=").append(qOpToGr);
        sb.append(", qRoe=").append(qRoe);
        sb.append(", qDtRoe=").append(qDtRoe);
        sb.append(", qNpta=").append(qNpta);
        sb.append(", qOpincomeToEbt=").append(qOpincomeToEbt);
        sb.append(", qInvestincomeToEbt=").append(qInvestincomeToEbt);
        sb.append(", qDtprofitToProfit=").append(qDtprofitToProfit);
        sb.append(", qSalescashToOr=").append(qSalescashToOr);
        sb.append(", qOcfToSales=").append(qOcfToSales);
        sb.append(", qOcfToOr=").append(qOcfToOr);
        sb.append(", basicEpsYoy=").append(basicEpsYoy);
        sb.append(", dtEpsYoy=").append(dtEpsYoy);
        sb.append(", cfpsYoy=").append(cfpsYoy);
        sb.append(", opYoy=").append(opYoy);
        sb.append(", ebtYoy=").append(ebtYoy);
        sb.append(", netprofitYoy=").append(netprofitYoy);
        sb.append(", dtNetprofitYoy=").append(dtNetprofitYoy);
        sb.append(", ocfYoy=").append(ocfYoy);
        sb.append(", roeYoy=").append(roeYoy);
        sb.append(", bpsYoy=").append(bpsYoy);
        sb.append(", assetsYoy=").append(assetsYoy);
        sb.append(", eqtYoy=").append(eqtYoy);
        sb.append(", trYoy=").append(trYoy);
        sb.append(", orYoy=").append(orYoy);
        sb.append(", qGrYoy=").append(qGrYoy);
        sb.append(", qGrQoq=").append(qGrQoq);
        sb.append(", qSalesYoy=").append(qSalesYoy);
        sb.append(", qSalesQoq=").append(qSalesQoq);
        sb.append(", qOpYoy=").append(qOpYoy);
        sb.append(", qOpQoq=").append(qOpQoq);
        sb.append(", qProfitYoy=").append(qProfitYoy);
        sb.append(", qProfitQoq=").append(qProfitQoq);
        sb.append(", qNetprofitYoy=").append(qNetprofitYoy);
        sb.append(", qNetprofitQoq=").append(qNetprofitQoq);
        sb.append(", equityYoy=").append(equityYoy);
        sb.append(", rdExp=").append(rdExp);
        sb.append(", updateFlag=").append(updateFlag);
        sb.append("]");
        return sb.toString();
    }
}